GitHub
commit
3c6599e66f
@ -0,0 +1,65 @@
|
|||||||
|
use crate::error::RepoResult;
|
||||||
|
use multihash::{Code, MultihashDigest};
|
||||||
|
|
||||||
|
/// Creates a new content descriptor for the given file
|
||||||
|
pub fn create_content_descriptor(bytes: &[u8]) -> Vec<u8> {
|
||||||
|
Code::Sha2_256.digest(bytes).to_bytes()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Encodes a content descriptor while respecting the version
|
||||||
|
pub fn encode_content_descriptor(descriptor: &[u8]) -> String {
|
||||||
|
if is_v1_content_descriptor(descriptor) {
|
||||||
|
encode_content_descriptor_v1(descriptor)
|
||||||
|
} else {
|
||||||
|
encode_content_descriptor_v2(descriptor)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Encodes a v1 descriptor that is already stored encoded in the database (only interprets it as string)
|
||||||
|
pub fn encode_content_descriptor_v1(descriptor: &[u8]) -> String {
|
||||||
|
String::from_utf8_lossy(descriptor).to_string()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Encodes the content descriptor as base32 lowercase
|
||||||
|
pub fn encode_content_descriptor_v2(descriptor: &[u8]) -> String {
|
||||||
|
data_encoding::BASE32_DNSSEC.encode(descriptor)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decodes a content descriptor
|
||||||
|
pub fn decode_content_descriptor<S: AsRef<str>>(descriptor: S) -> RepoResult<Vec<u8>> {
|
||||||
|
// check for v1 descriptor with a fixed length of 53 starting with the prefix of the base and hash
|
||||||
|
if is_v1_content_descriptor_string(descriptor.as_ref()) {
|
||||||
|
decode_content_descriptor_v1(descriptor)
|
||||||
|
} else {
|
||||||
|
decode_content_descriptor_v2(descriptor)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decodes the first version of content descriptors (multibase)
|
||||||
|
pub fn decode_content_descriptor_v1<S: AsRef<str>>(descriptor: S) -> RepoResult<Vec<u8>> {
|
||||||
|
Ok(descriptor.as_ref().as_bytes().to_vec())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decodes the second version of content descriptors (faster fixed base32)
|
||||||
|
pub fn decode_content_descriptor_v2<S: AsRef<str>>(descriptor: S) -> RepoResult<Vec<u8>> {
|
||||||
|
let data = data_encoding::BASE32_DNSSEC.decode(descriptor.as_ref().as_bytes())?;
|
||||||
|
|
||||||
|
Ok(data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decodes the data stored in the v1 content descriptor into the v2 format
|
||||||
|
pub fn convert_v1_descriptor_to_v2(descriptor_v1: &[u8]) -> RepoResult<Vec<u8>> {
|
||||||
|
let (_, data) = multibase::decode(encode_content_descriptor_v1(descriptor_v1))?;
|
||||||
|
|
||||||
|
Ok(data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Checks if a binary descriptor is v1
|
||||||
|
pub fn is_v1_content_descriptor(descriptor: &[u8]) -> bool {
|
||||||
|
descriptor.len() == 56 && descriptor.starts_with(b"bciq")
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Checks if a descriptor string is a v1 descriptor
|
||||||
|
pub fn is_v1_content_descriptor_string<S: AsRef<str>>(descriptor: S) -> bool {
|
||||||
|
descriptor.as_ref().len() == 56 && descriptor.as_ref().starts_with("bciq")
|
||||||
|
}
|
||||||
@ -0,0 +1,35 @@
|
|||||||
|
use std::io::Result;
|
||||||
|
use std::path::{Path, PathBuf};
|
||||||
|
use tokio::fs::{File, OpenOptions};
|
||||||
|
|
||||||
|
/// A file that only exists while being owned.
|
||||||
|
/// Will automatically be deleted on Drop
|
||||||
|
pub struct DropFile {
|
||||||
|
path: PathBuf,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl DropFile {
|
||||||
|
pub async fn new<P: AsRef<Path>>(path: P) -> Result<(File, Self)> {
|
||||||
|
let file = OpenOptions::new()
|
||||||
|
.write(true)
|
||||||
|
.read(true)
|
||||||
|
.create(true)
|
||||||
|
.open(path.as_ref())
|
||||||
|
.await?;
|
||||||
|
Ok((file, Self::from_path(path)))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn from_path<P: AsRef<Path>>(path: P) -> Self {
|
||||||
|
Self {
|
||||||
|
path: path.as_ref().to_path_buf(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for DropFile {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
if let Err(e) = std::fs::remove_file(&self.path) {
|
||||||
|
tracing::error!("failed to remove drop file '{}'", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1,2 +1,3 @@
|
|||||||
|
pub mod drop_file;
|
||||||
pub mod file_hash_store;
|
pub mod file_hash_store;
|
||||||
pub mod thumbnail_store;
|
pub mod thumbnail_store;
|
||||||
|
|||||||
@ -1,38 +0,0 @@
|
|||||||
use crate::error::RepoResult;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use std::net::IpAddr;
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
|
||||||
pub struct Settings {
|
|
||||||
pub listen_address: IpAddr,
|
|
||||||
pub port_range: (u16, u16),
|
|
||||||
pub database_path: String,
|
|
||||||
pub default_file_store: String,
|
|
||||||
pub thumbnail_store: String,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for Settings {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
listen_address: IpAddr::from([127, 0, 0, 1]),
|
|
||||||
port_range: (3400, 3500),
|
|
||||||
database_path: "./db/repo.db".to_string(),
|
|
||||||
default_file_store: "Main".to_string(),
|
|
||||||
thumbnail_store: "./thumbnails".to_string(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Settings {
|
|
||||||
/// Parses settings from a string
|
|
||||||
pub fn from_toml_string(s: &str) -> RepoResult<Self> {
|
|
||||||
let settings = toml::from_str(s)?;
|
|
||||||
Ok(settings)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the settings into a toml string
|
|
||||||
pub fn to_toml_string(&self) -> RepoResult<String> {
|
|
||||||
let string = toml::to_string(&self)?;
|
|
||||||
Ok(string)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,42 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use tracing::Level;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub struct LoggingSettings {
|
||||||
|
pub level: LogLevel,
|
||||||
|
pub trace_sql: bool,
|
||||||
|
pub trace_api_calls: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for LoggingSettings {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self {
|
||||||
|
level: LogLevel::Info,
|
||||||
|
trace_sql: false,
|
||||||
|
trace_api_calls: false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub enum LogLevel {
|
||||||
|
Off,
|
||||||
|
Error,
|
||||||
|
Warn,
|
||||||
|
Info,
|
||||||
|
Debug,
|
||||||
|
Trace,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Into<Option<Level>> for LogLevel {
|
||||||
|
fn into(self) -> Option<Level> {
|
||||||
|
match self {
|
||||||
|
LogLevel::Off => None,
|
||||||
|
LogLevel::Error => Some(Level::ERROR),
|
||||||
|
LogLevel::Warn => Some(Level::WARN),
|
||||||
|
LogLevel::Info => Some(Level::INFO),
|
||||||
|
LogLevel::Debug => Some(Level::DEBUG),
|
||||||
|
LogLevel::Trace => Some(Level::TRACE),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,76 @@
|
|||||||
|
mod logging;
|
||||||
|
mod paths;
|
||||||
|
mod server;
|
||||||
|
pub mod v1;
|
||||||
|
|
||||||
|
use crate::error::RepoResult;
|
||||||
|
use crate::settings::v1::SettingsV1;
|
||||||
|
use config::{Config, FileFormat};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use std::fs;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
pub use logging::*;
|
||||||
|
pub use paths::*;
|
||||||
|
pub use server::*;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize, Default)]
|
||||||
|
pub struct Settings {
|
||||||
|
pub server: ServerSettings,
|
||||||
|
pub paths: PathSettings,
|
||||||
|
pub logging: LoggingSettings,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Settings {
|
||||||
|
pub fn read(root: &PathBuf) -> RepoResult<Self> {
|
||||||
|
let mut settings = Config::default();
|
||||||
|
settings
|
||||||
|
.merge(config::File::from_str(
|
||||||
|
&*Settings::default().to_toml_string()?,
|
||||||
|
FileFormat::Toml,
|
||||||
|
))?
|
||||||
|
.merge(config::File::from(root.join("repo")))?
|
||||||
|
.merge(config::Environment::with_prefix("MEDIAREPO").separator("."))?;
|
||||||
|
tracing::debug!("Settings are: {:#?}", settings);
|
||||||
|
|
||||||
|
Ok(settings.try_into::<Settings>()?)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses settings from a string
|
||||||
|
pub fn from_v1(settings_v1: SettingsV1) -> RepoResult<Self> {
|
||||||
|
let mut settings_main = Settings::default();
|
||||||
|
settings_main.server.tcp.enabled = true;
|
||||||
|
settings_main.server.tcp.port = PortSetting::Range(settings_v1.port_range);
|
||||||
|
settings_main.server.tcp.listen_address = settings_v1.listen_address;
|
||||||
|
settings_main.paths.thumbnail_directory = settings_v1.thumbnail_store.into();
|
||||||
|
settings_main.paths.database_directory = PathBuf::from(settings_v1.database_path)
|
||||||
|
.parent()
|
||||||
|
.map(|p| p.to_string_lossy().to_string())
|
||||||
|
.unwrap_or_else(|| String::from("./"));
|
||||||
|
|
||||||
|
let mut settings = Config::default();
|
||||||
|
settings
|
||||||
|
.merge(config::File::from_str(
|
||||||
|
&*settings_main.to_toml_string()?,
|
||||||
|
FileFormat::Toml,
|
||||||
|
))?
|
||||||
|
.merge(config::Environment::with_prefix("MEDIAREPO"))?;
|
||||||
|
tracing::debug!("Settings are: {:#?}", settings);
|
||||||
|
|
||||||
|
Ok(settings.try_into::<Settings>()?)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts the settings into a toml string
|
||||||
|
pub fn to_toml_string(&self) -> RepoResult<String> {
|
||||||
|
let string = toml::to_string(&self)?;
|
||||||
|
|
||||||
|
Ok(string)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn save(&self, root: &PathBuf) -> RepoResult<()> {
|
||||||
|
let string = toml::to_string_pretty(&self)?;
|
||||||
|
fs::write(root.join("repo.toml"), string.into_bytes())?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,46 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub struct PathSettings {
|
||||||
|
pub(crate) database_directory: String,
|
||||||
|
pub(crate) files_directory: String,
|
||||||
|
pub(crate) thumbnail_directory: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for PathSettings {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self {
|
||||||
|
database_directory: String::from("db"),
|
||||||
|
files_directory: String::from("files"),
|
||||||
|
thumbnail_directory: String::from("thumbnails"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PathSettings {
|
||||||
|
#[inline]
|
||||||
|
pub fn database_dir(&self, root: &PathBuf) -> PathBuf {
|
||||||
|
root.join(&self.database_directory)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn files_dir(&self, root: &PathBuf) -> PathBuf {
|
||||||
|
root.join(&self.files_directory)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn thumbs_dir(&self, root: &PathBuf) -> PathBuf {
|
||||||
|
root.join(&self.thumbnail_directory)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn db_file_path(&self, root: &PathBuf) -> PathBuf {
|
||||||
|
self.database_dir(root).join("repo.db")
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn frontend_state_file_path(&self, root: &PathBuf) -> PathBuf {
|
||||||
|
self.database_dir(root).join("frontend-state.json")
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,46 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use std::net::IpAddr;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize, Default)]
|
||||||
|
pub struct ServerSettings {
|
||||||
|
pub tcp: TcpServerSettings,
|
||||||
|
#[cfg(unix)]
|
||||||
|
pub unix_socket: UnixSocketServerSettings,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub struct TcpServerSettings {
|
||||||
|
pub enabled: bool,
|
||||||
|
pub listen_address: IpAddr,
|
||||||
|
pub port: PortSetting,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
#[serde(untagged)]
|
||||||
|
pub enum PortSetting {
|
||||||
|
Fixed(u16),
|
||||||
|
Range((u16, u16)),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for TcpServerSettings {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self {
|
||||||
|
enabled: cfg!(windows),
|
||||||
|
listen_address: IpAddr::from([127, 0, 0, 1]),
|
||||||
|
port: PortSetting::Range((13400, 13500)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub struct UnixSocketServerSettings {
|
||||||
|
pub enabled: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
impl Default for UnixSocketServerSettings {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self { enabled: true }
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,20 @@
|
|||||||
|
use crate::error::RepoResult;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use std::net::IpAddr;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||||
|
pub struct SettingsV1 {
|
||||||
|
pub listen_address: IpAddr,
|
||||||
|
pub port_range: (u16, u16),
|
||||||
|
pub database_path: String,
|
||||||
|
pub default_file_store: String,
|
||||||
|
pub thumbnail_store: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SettingsV1 {
|
||||||
|
/// Parses settings from a string
|
||||||
|
pub fn from_toml_string(s: &str) -> RepoResult<Self> {
|
||||||
|
let settings = toml::from_str(s)?;
|
||||||
|
Ok(settings)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,107 @@
|
|||||||
|
-- Add migration script here
|
||||||
|
PRAGMA foreign_keys= off;
|
||||||
|
|
||||||
|
-- create backup files table
|
||||||
|
ALTER TABLE files
|
||||||
|
RENAME TO _files_old;
|
||||||
|
|
||||||
|
-- create backup hashes table
|
||||||
|
ALTER TABLE hashes
|
||||||
|
RENAME TO _hashes_old;
|
||||||
|
|
||||||
|
-- create backup hash_tag_mappings table
|
||||||
|
ALTER TABLE hash_tag_mappings
|
||||||
|
RENAME TO _hash_tag_mappings_old;
|
||||||
|
|
||||||
|
-- create backup hash_source_mappings table
|
||||||
|
ALTER TABLE hash_source_mappings
|
||||||
|
RENAME TO _hash_source_mappings_old;
|
||||||
|
|
||||||
|
-- create content id table
|
||||||
|
CREATE TABLE content_descriptors
|
||||||
|
(
|
||||||
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
|
descriptor BLOB NOT NULL
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE UNIQUE INDEX content_descriptor_values ON content_descriptors (descriptor);
|
||||||
|
|
||||||
|
-- create content-id tag mappings table
|
||||||
|
CREATE TABLE cd_tag_mappings
|
||||||
|
(
|
||||||
|
cd_id INTEGER NOT NULL REFERENCES content_descriptors (id),
|
||||||
|
tag_id INTEGER NOT NULL REFERENCES tags (id),
|
||||||
|
PRIMARY KEY (cd_id, tag_id)
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE UNIQUE INDEX content_descriptor_tag_mapping_unique ON cd_tag_mappings (cd_id, tag_id);
|
||||||
|
CREATE INDEX content_descriptor_tag_mapping_tag ON cd_tag_mappings (tag_id);
|
||||||
|
|
||||||
|
-- create content-id source mappings table
|
||||||
|
CREATE TABLE cd_source_mappings
|
||||||
|
(
|
||||||
|
cd_id INTEGER NOT NULL REFERENCES content_descriptors (id),
|
||||||
|
source_id INTEGER NOT NULL REFERENCES sources (id),
|
||||||
|
PRIMARY KEY (cd_id, source_id)
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE UNIQUE INDEX content_descriptor_source_mapping_unique ON cd_source_mappings (cd_id, source_id);
|
||||||
|
|
||||||
|
-- create new files table
|
||||||
|
CREATE TABLE files
|
||||||
|
(
|
||||||
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
|
status INTEGER NOT NULL DEFAULT 10,
|
||||||
|
storage_id INTEGER NOT NULL REFERENCES storage_locations (id),
|
||||||
|
cd_id INTEGER NOT NULL REFERENCES content_descriptors (id),
|
||||||
|
mime_type VARCHAR(128) NOT NULL DEFAULT 'application/octet-stream'
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE INDEX files_contend_descriptor ON files (cd_id);
|
||||||
|
|
||||||
|
-- create metadata table
|
||||||
|
CREATE TABLE file_metadata
|
||||||
|
(
|
||||||
|
file_id INTEGER PRIMARY KEY REFERENCES files (id),
|
||||||
|
size INTEGER NOT NULL,
|
||||||
|
name VARCHAR(128),
|
||||||
|
comment VARCHAR(1024),
|
||||||
|
import_time DATETIME NOT NULL,
|
||||||
|
creation_time DATETIME NOT NULL,
|
||||||
|
change_time DATETIME NOT NULL
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE UNIQUE INDEX file_metadata_file_id_unique ON file_metadata (file_id);
|
||||||
|
|
||||||
|
-- add content identifiers from hashes table
|
||||||
|
INSERT INTO content_descriptors
|
||||||
|
SELECT id, value
|
||||||
|
FROM _hashes_old;
|
||||||
|
|
||||||
|
-- add files from files table
|
||||||
|
INSERT INTO files (id, storage_id, cd_id, mime_type)
|
||||||
|
SELECT id, storage_id, hash_id AS content_id, mime_type
|
||||||
|
FROM _files_old;
|
||||||
|
|
||||||
|
-- add metadata from files table
|
||||||
|
INSERT INTO file_metadata
|
||||||
|
SELECT id AS file_id, size, name, comment, import_time, creation_time, change_time
|
||||||
|
FROM _files_old;
|
||||||
|
|
||||||
|
-- add content tag mappings
|
||||||
|
INSERT INTO cd_tag_mappings
|
||||||
|
SELECT hash_id AS content_id, tag_id
|
||||||
|
FROM _hash_tag_mappings_old;
|
||||||
|
|
||||||
|
-- add content id source mappings
|
||||||
|
INSERT INTO cd_source_mappings
|
||||||
|
SELECT hash_id AS content_id, source_id
|
||||||
|
FROM _hash_source_mappings_old;
|
||||||
|
|
||||||
|
-- drop all old tables
|
||||||
|
DROP TABLE _hash_source_mappings_old;
|
||||||
|
DROP TABLE _hash_tag_mappings_old;
|
||||||
|
DROP TABLE _files_old;
|
||||||
|
DROP TABLE _hashes_old;
|
||||||
|
|
||||||
|
pragma foreign_keys= on;
|
||||||
@ -0,0 +1,50 @@
|
|||||||
|
-- Add migration script here
|
||||||
|
PRAGMA foreign_keys= off;
|
||||||
|
|
||||||
|
-- rename old files table
|
||||||
|
ALTER TABLE files
|
||||||
|
RENAME TO _files_old;
|
||||||
|
-- rename metadata value (because of foreign key constraints)
|
||||||
|
ALTER TABLE file_metadata
|
||||||
|
RENAME TO _file_metadata_old;
|
||||||
|
|
||||||
|
-- create new files table
|
||||||
|
CREATE TABLE files
|
||||||
|
(
|
||||||
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
|
status INTEGER NOT NULL DEFAULT 10,
|
||||||
|
cd_id INTEGER NOT NULL REFERENCES content_descriptors (id),
|
||||||
|
mime_type VARCHAR(128) NOT NULL DEFAULT 'application/octet-stream'
|
||||||
|
);
|
||||||
|
-- add data from files table
|
||||||
|
INSERT INTO files
|
||||||
|
SELECT id, status, cd_id, mime_type
|
||||||
|
FROM _files_old;
|
||||||
|
|
||||||
|
-- create metadata table
|
||||||
|
CREATE TABLE file_metadata
|
||||||
|
(
|
||||||
|
file_id INTEGER PRIMARY KEY REFERENCES files (id),
|
||||||
|
size INTEGER NOT NULL,
|
||||||
|
name VARCHAR(128),
|
||||||
|
comment VARCHAR(1024),
|
||||||
|
import_time DATETIME NOT NULL,
|
||||||
|
creation_time DATETIME NOT NULL,
|
||||||
|
change_time DATETIME NOT NULL
|
||||||
|
);
|
||||||
|
|
||||||
|
-- add back the old values
|
||||||
|
INSERT INTO file_metadata
|
||||||
|
SELECT *
|
||||||
|
FROM _file_metadata_old;
|
||||||
|
|
||||||
|
-- drop old tables
|
||||||
|
DROP TABLE _file_metadata_old;
|
||||||
|
DROP TABLE _files_old;
|
||||||
|
DROP TABLE storage_locations;
|
||||||
|
|
||||||
|
-- create indices on new tables
|
||||||
|
CREATE UNIQUE INDEX file_metadata_file_id_unique ON file_metadata (file_id);
|
||||||
|
CREATE INDEX files_content_descriptor ON files (cd_id);
|
||||||
|
|
||||||
|
PRAGMA foreign_keys= on;
|
||||||
@ -0,0 +1,32 @@
|
|||||||
|
use chrono::NaiveDateTime;
|
||||||
|
use sea_orm::prelude::*;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
|
||||||
|
#[sea_orm(table_name = "file_metadata")]
|
||||||
|
pub struct Model {
|
||||||
|
#[sea_orm(primary_key)]
|
||||||
|
pub file_id: i64,
|
||||||
|
pub name: Option<String>,
|
||||||
|
pub comment: Option<String>,
|
||||||
|
pub size: i64,
|
||||||
|
pub import_time: NaiveDateTime,
|
||||||
|
pub creation_time: NaiveDateTime,
|
||||||
|
pub change_time: NaiveDateTime,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
||||||
|
pub enum Relation {
|
||||||
|
#[sea_orm(
|
||||||
|
belongs_to = "super::file::Entity",
|
||||||
|
from = "Column::FileId",
|
||||||
|
to = "super::file::Column::Id"
|
||||||
|
)]
|
||||||
|
File,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Related<super::file::Entity> for Entity {
|
||||||
|
fn to() -> RelationDef {
|
||||||
|
Relation::File.def()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl ActiveModelBehavior for ActiveModel {}
|
||||||
@ -1,8 +1,8 @@
|
|||||||
|
pub mod content_descriptor;
|
||||||
|
pub mod content_descriptor_source;
|
||||||
|
pub mod content_descriptor_tag;
|
||||||
pub mod file;
|
pub mod file;
|
||||||
pub mod hash;
|
pub mod file_metadata;
|
||||||
pub mod hash_source;
|
|
||||||
pub mod hash_tag;
|
|
||||||
pub mod namespace;
|
pub mod namespace;
|
||||||
pub mod source;
|
pub mod source;
|
||||||
pub mod storage;
|
|
||||||
pub mod tag;
|
pub mod tag;
|
||||||
|
|||||||
@ -1,24 +0,0 @@
|
|||||||
use sea_orm::prelude::*;
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
|
|
||||||
#[sea_orm(table_name = "storage_locations")]
|
|
||||||
pub struct Model {
|
|
||||||
#[sea_orm(primary_key)]
|
|
||||||
pub id: i64,
|
|
||||||
pub name: String,
|
|
||||||
pub path: String,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
|
||||||
pub enum Relation {
|
|
||||||
#[sea_orm(has_many = "super::file::Entity")]
|
|
||||||
File,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Related<super::file::Entity> for Entity {
|
|
||||||
fn to() -> RelationDef {
|
|
||||||
Relation::File.def()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ActiveModelBehavior for ActiveModel {}
|
|
||||||
@ -1,395 +0,0 @@
|
|||||||
use std::fmt::Debug;
|
|
||||||
use std::io::Cursor;
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use chrono::{Local, NaiveDateTime};
|
|
||||||
use sea_orm::prelude::*;
|
|
||||||
use sea_orm::sea_query::{Expr, Query};
|
|
||||||
use sea_orm::{Condition, DatabaseConnection, Set};
|
|
||||||
use sea_orm::{JoinType, QuerySelect};
|
|
||||||
use tokio::io::{AsyncReadExt, BufReader};
|
|
||||||
|
|
||||||
use mediarepo_core::error::RepoResult;
|
|
||||||
use mediarepo_core::thumbnailer::{self, Thumbnail as ThumbnailerThumb, ThumbnailSize};
|
|
||||||
use mediarepo_database::entities::file;
|
|
||||||
use mediarepo_database::entities::hash;
|
|
||||||
use mediarepo_database::entities::hash_tag;
|
|
||||||
use mediarepo_database::entities::namespace;
|
|
||||||
use mediarepo_database::entities::tag;
|
|
||||||
|
|
||||||
use crate::file_type::FileType;
|
|
||||||
use crate::storage::Storage;
|
|
||||||
use crate::tag::Tag;
|
|
||||||
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct File {
|
|
||||||
db: DatabaseConnection,
|
|
||||||
model: file::Model,
|
|
||||||
hash: hash::Model,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl File {
|
|
||||||
#[tracing::instrument(level = "trace")]
|
|
||||||
pub(crate) fn new(db: DatabaseConnection, model: file::Model, hash: hash::Model) -> Self {
|
|
||||||
Self { db, model, hash }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a list of all known stored files
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn all(db: DatabaseConnection) -> RepoResult<Vec<File>> {
|
|
||||||
let files: Vec<(file::Model, Option<hash::Model>)> = file::Entity::find()
|
|
||||||
.find_also_related(hash::Entity)
|
|
||||||
.all(&db)
|
|
||||||
.await?;
|
|
||||||
let files = files
|
|
||||||
.into_iter()
|
|
||||||
.filter_map(|(f, h)| {
|
|
||||||
let h = h?;
|
|
||||||
Some(Self::new(db.clone(), f, h))
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
Ok(files)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Fetches the file by id
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn by_id(db: DatabaseConnection, id: i64) -> RepoResult<Option<Self>> {
|
|
||||||
if let Some((model, Some(hash))) = file::Entity::find_by_id(id)
|
|
||||||
.find_also_related(hash::Entity)
|
|
||||||
.one(&db)
|
|
||||||
.await?
|
|
||||||
{
|
|
||||||
let file = File::new(db, model, hash);
|
|
||||||
Ok(Some(file))
|
|
||||||
} else {
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Finds the file by hash
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn by_hash<S: AsRef<str> + Debug>(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
hash: S,
|
|
||||||
) -> RepoResult<Option<Self>> {
|
|
||||||
if let Some((hash, Some(model))) = hash::Entity::find()
|
|
||||||
.filter(hash::Column::Value.eq(hash.as_ref()))
|
|
||||||
.find_also_related(file::Entity)
|
|
||||||
.one(&db)
|
|
||||||
.await?
|
|
||||||
{
|
|
||||||
let file = File::new(db, model, hash);
|
|
||||||
Ok(Some(file))
|
|
||||||
} else {
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Finds the file by tags
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub(crate) async fn find_by_tags(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
tag_ids: Vec<Vec<(i64, bool)>>,
|
|
||||||
) -> RepoResult<Vec<Self>> {
|
|
||||||
let main_condition = build_find_filter_conditions(tag_ids);
|
|
||||||
|
|
||||||
let results: Vec<(hash::Model, Option<file::Model>)> = hash::Entity::find()
|
|
||||||
.find_also_related(file::Entity)
|
|
||||||
.filter(main_condition)
|
|
||||||
.group_by(file::Column::Id)
|
|
||||||
.all(&db)
|
|
||||||
.await?;
|
|
||||||
let files: Vec<Self> = results
|
|
||||||
.into_iter()
|
|
||||||
.filter_map(|(hash, tag)| Some(Self::new(db.clone(), tag?, hash)))
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
Ok(files)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds a file with its hash to the database
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub(crate) async fn add(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
storage_id: i64,
|
|
||||||
hash_id: i64,
|
|
||||||
file_type: FileType,
|
|
||||||
mime_type: Option<String>,
|
|
||||||
creation_time: NaiveDateTime,
|
|
||||||
change_time: NaiveDateTime,
|
|
||||||
) -> RepoResult<Self> {
|
|
||||||
let file = file::ActiveModel {
|
|
||||||
hash_id: Set(hash_id),
|
|
||||||
file_type: Set(file_type as u32),
|
|
||||||
mime_type: Set(mime_type),
|
|
||||||
storage_id: Set(storage_id),
|
|
||||||
import_time: Set(Local::now().naive_local()),
|
|
||||||
creation_time: Set(creation_time),
|
|
||||||
change_time: Set(change_time),
|
|
||||||
..Default::default()
|
|
||||||
};
|
|
||||||
let file: file::ActiveModel = file.insert(&db).await?.into();
|
|
||||||
let file = Self::by_id(db, file.id.unwrap())
|
|
||||||
.await?
|
|
||||||
.expect("Inserted file does not exist");
|
|
||||||
|
|
||||||
Ok(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the unique identifier of the file
|
|
||||||
pub fn id(&self) -> i64 {
|
|
||||||
self.model.id
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the hash of the file (content identifier)
|
|
||||||
pub fn hash(&self) -> &String {
|
|
||||||
&self.hash.value
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the hash id of the file
|
|
||||||
pub fn hash_id(&self) -> i64 {
|
|
||||||
self.hash.id
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the type of the file
|
|
||||||
pub fn file_type(&self) -> FileType {
|
|
||||||
match self.model.file_type {
|
|
||||||
1 => FileType::Image,
|
|
||||||
2 => FileType::Video,
|
|
||||||
3 => FileType::Audio,
|
|
||||||
_ => FileType::Unknown,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the optional mime type of the file
|
|
||||||
pub fn mime_type(&self) -> &Option<String> {
|
|
||||||
&self.model.mime_type
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the optional name of the file
|
|
||||||
pub fn name(&self) -> &Option<String> {
|
|
||||||
&self.model.name
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the comment of the file
|
|
||||||
pub fn comment(&self) -> &Option<String> {
|
|
||||||
&self.model.comment
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the import time of the file
|
|
||||||
pub fn import_time(&self) -> &NaiveDateTime {
|
|
||||||
&self.model.import_time
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the datetime when the file was created
|
|
||||||
pub fn creation_time(&self) -> &NaiveDateTime {
|
|
||||||
&self.model.creation_time
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the last time the file was changed
|
|
||||||
pub fn change_time(&self) -> &NaiveDateTime {
|
|
||||||
&self.model.change_time
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the storage where the file is stored
|
|
||||||
pub async fn storage(&self) -> RepoResult<Storage> {
|
|
||||||
let storage = Storage::by_id(self.db.clone(), self.model.storage_id)
|
|
||||||
.await?
|
|
||||||
.expect("The FK storage_id doesn't exist?!");
|
|
||||||
|
|
||||||
Ok(storage)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the list of tags of the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn tags(&self) -> RepoResult<Vec<Tag>> {
|
|
||||||
let tags: Vec<(tag::Model, Option<namespace::Model>)> = tag::Entity::find()
|
|
||||||
.find_also_related(namespace::Entity)
|
|
||||||
.join(JoinType::LeftJoin, hash_tag::Relation::Tag.def().rev())
|
|
||||||
.join(JoinType::InnerJoin, hash_tag::Relation::Hash.def())
|
|
||||||
.filter(hash::Column::Id.eq(self.hash.id))
|
|
||||||
.all(&self.db)
|
|
||||||
.await?;
|
|
||||||
let tags = tags
|
|
||||||
.into_iter()
|
|
||||||
.map(|(tag, namespace)| Tag::new(self.db.clone(), tag, namespace))
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
Ok(tags)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Changes the name of the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn set_name<S: ToString + Debug>(&mut self, name: S) -> RepoResult<()> {
|
|
||||||
let mut active_file = self.get_active_model();
|
|
||||||
active_file.name = Set(Some(name.to_string()));
|
|
||||||
let active_file = active_file.update(&self.db).await?;
|
|
||||||
self.model.name = active_file.name;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Changes the comment of the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn set_comment<S: ToString + Debug>(&mut self, comment: S) -> RepoResult<()> {
|
|
||||||
let mut active_file = self.get_active_model();
|
|
||||||
active_file.comment = Set(Some(comment.to_string()));
|
|
||||||
let active_file = active_file.update(&self.db).await?;
|
|
||||||
self.model.comment = active_file.comment;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Changes the type of the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn set_file_type(&mut self, file_type: FileType) -> RepoResult<()> {
|
|
||||||
let mut active_file = self.get_active_model();
|
|
||||||
active_file.file_type = Set(file_type as u32);
|
|
||||||
let active_file = active_file.update(&self.db).await?;
|
|
||||||
self.model.file_type = active_file.file_type;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds a single tag to the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn add_tag(&mut self, tag_id: i64) -> RepoResult<()> {
|
|
||||||
let hash_id = self.hash.id;
|
|
||||||
let active_model = hash_tag::ActiveModel {
|
|
||||||
hash_id: Set(hash_id),
|
|
||||||
tag_id: Set(tag_id),
|
|
||||||
};
|
|
||||||
active_model.insert(&self.db).await?;
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds multiple tags to the file at once
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn add_tags(&self, tag_ids: Vec<i64>) -> RepoResult<()> {
|
|
||||||
if tag_ids.is_empty() {
|
|
||||||
return Ok(());
|
|
||||||
}
|
|
||||||
let hash_id = self.hash.id;
|
|
||||||
let models: Vec<hash_tag::ActiveModel> = tag_ids
|
|
||||||
.into_iter()
|
|
||||||
.map(|tag_id| hash_tag::ActiveModel {
|
|
||||||
hash_id: Set(hash_id),
|
|
||||||
tag_id: Set(tag_id),
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
hash_tag::Entity::insert_many(models).exec(&self.db).await?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Removes multiple tags from the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn remove_tags(&self, tag_ids: Vec<i64>) -> RepoResult<()> {
|
|
||||||
let hash_id = self.hash.id;
|
|
||||||
hash_tag::Entity::delete_many()
|
|
||||||
.filter(hash_tag::Column::HashId.eq(hash_id))
|
|
||||||
.filter(hash_tag::Column::TagId.is_in(tag_ids))
|
|
||||||
.exec(&self.db)
|
|
||||||
.await?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the reader for the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn get_reader(&self) -> RepoResult<BufReader<tokio::fs::File>> {
|
|
||||||
let storage = self.storage().await?;
|
|
||||||
|
|
||||||
storage.get_file_reader(&self.hash.value).await
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Retrieves the size of the file from its content
|
|
||||||
#[tracing::instrument(level = "trace", skip(self))]
|
|
||||||
pub async fn get_size(&self) -> RepoResult<u64> {
|
|
||||||
if let Some(size) = self.model.size {
|
|
||||||
Ok(size as u64)
|
|
||||||
} else {
|
|
||||||
let mut reader = self.get_reader().await?;
|
|
||||||
let size = {
|
|
||||||
let mut buf = Vec::new();
|
|
||||||
reader.read_to_end(&mut buf).await
|
|
||||||
}?;
|
|
||||||
let mut model = self.get_active_model();
|
|
||||||
model.size = Set(Some(size as i64));
|
|
||||||
model.update(&self.db).await?;
|
|
||||||
|
|
||||||
Ok(size as u64)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a thumbnail for the file
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn create_thumbnail<I: IntoIterator<Item = ThumbnailSize> + Debug>(
|
|
||||||
&self,
|
|
||||||
sizes: I,
|
|
||||||
) -> RepoResult<Vec<ThumbnailerThumb>> {
|
|
||||||
let mut buf = Vec::new();
|
|
||||||
self.get_reader().await?.read_to_end(&mut buf).await?;
|
|
||||||
let mime_type = self
|
|
||||||
.model
|
|
||||||
.mime_type
|
|
||||||
.clone()
|
|
||||||
.map(|mime_type| mime::Mime::from_str(&mime_type).unwrap())
|
|
||||||
.unwrap_or(mime::IMAGE_STAR);
|
|
||||||
let thumbs = thumbnailer::create_thumbnails(Cursor::new(buf), mime_type, sizes)?;
|
|
||||||
|
|
||||||
Ok(thumbs)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the active model of the file with only the id set
|
|
||||||
fn get_active_model(&self) -> file::ActiveModel {
|
|
||||||
file::ActiveModel {
|
|
||||||
id: Set(self.id()),
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn build_find_filter_conditions(tag_ids: Vec<Vec<(i64, bool)>>) -> Condition {
|
|
||||||
let mut main_condition = Condition::all();
|
|
||||||
|
|
||||||
for mut expression in tag_ids {
|
|
||||||
if expression.len() == 1 {
|
|
||||||
let (tag_id, negated) = expression.pop().unwrap();
|
|
||||||
main_condition = add_single_filter_expression(main_condition, tag_id, negated)
|
|
||||||
} else if !expression.is_empty() {
|
|
||||||
let mut sub_condition = Condition::any();
|
|
||||||
|
|
||||||
for (tag, negated) in expression {
|
|
||||||
sub_condition = add_single_filter_expression(sub_condition, tag, negated);
|
|
||||||
}
|
|
||||||
main_condition = main_condition.add(sub_condition);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
main_condition
|
|
||||||
}
|
|
||||||
|
|
||||||
fn add_single_filter_expression(condition: Condition, tag_id: i64, negated: bool) -> Condition {
|
|
||||||
if negated {
|
|
||||||
condition.add(
|
|
||||||
hash::Column::Id.not_in_subquery(
|
|
||||||
Query::select()
|
|
||||||
.expr(Expr::col(hash_tag::Column::HashId))
|
|
||||||
.from(hash_tag::Entity)
|
|
||||||
.cond_where(hash_tag::Column::TagId.eq(tag_id))
|
|
||||||
.to_owned(),
|
|
||||||
),
|
|
||||||
)
|
|
||||||
} else {
|
|
||||||
condition.add(
|
|
||||||
hash::Column::Id.in_subquery(
|
|
||||||
Query::select()
|
|
||||||
.expr(Expr::col(hash_tag::Column::HashId))
|
|
||||||
.from(hash_tag::Entity)
|
|
||||||
.cond_where(hash_tag::Column::TagId.eq(tag_id))
|
|
||||||
.to_owned(),
|
|
||||||
),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,223 @@
|
|||||||
|
use chrono::NaiveDateTime;
|
||||||
|
use mediarepo_database::entities::content_descriptor;
|
||||||
|
use mediarepo_database::entities::content_descriptor_tag;
|
||||||
|
use mediarepo_database::entities::file;
|
||||||
|
use mediarepo_database::entities::file_metadata;
|
||||||
|
use sea_orm::sea_query::{Alias, Expr, Query, SimpleExpr};
|
||||||
|
use sea_orm::ColumnTrait;
|
||||||
|
use sea_orm::Condition;
|
||||||
|
|
||||||
|
macro_rules! apply_ordering_comparator {
|
||||||
|
($column:expr, $filter:expr) => {
|
||||||
|
match $filter {
|
||||||
|
OrderingComparator::Less(value) => $column.lt(value),
|
||||||
|
OrderingComparator::Equal(value) => $column.eq(value),
|
||||||
|
OrderingComparator::Greater(value) => $column.gt(value),
|
||||||
|
OrderingComparator::Between((min_value, max_value)) => {
|
||||||
|
$column.between(min_value, max_value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub enum FilterProperty {
|
||||||
|
TagId(NegatableComparator<i64>),
|
||||||
|
TagWildcardIds(NegatableComparator<Vec<i64>>),
|
||||||
|
ContentDescriptor(NegatableComparator<Vec<u8>>),
|
||||||
|
TagCount(OrderingComparator<i64>),
|
||||||
|
FileProperty(FilterFileProperty),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub enum FilterFileProperty {
|
||||||
|
Id(NegatableComparator<i64>),
|
||||||
|
Status(NegatableComparator<i64>),
|
||||||
|
FileSize(OrderingComparator<i64>),
|
||||||
|
ImportedTime(OrderingComparator<NaiveDateTime>),
|
||||||
|
ChangedTime(OrderingComparator<NaiveDateTime>),
|
||||||
|
CreatedTime(OrderingComparator<NaiveDateTime>),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub enum OrderingComparator<T> {
|
||||||
|
Less(T),
|
||||||
|
Equal(T),
|
||||||
|
Greater(T),
|
||||||
|
Between((T, T)),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub enum NegatableComparator<T> {
|
||||||
|
Is(T),
|
||||||
|
IsNot(T),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "debug")]
|
||||||
|
pub fn build_find_filter_conditions(filters: Vec<Vec<FilterProperty>>) -> Condition {
|
||||||
|
filters
|
||||||
|
.into_iter()
|
||||||
|
.fold(Condition::all(), |all_cond, mut expression| {
|
||||||
|
if expression.len() == 1 {
|
||||||
|
let property = expression.pop().unwrap();
|
||||||
|
|
||||||
|
all_cond.add(build_single_filter(property))
|
||||||
|
} else if !expression.is_empty() {
|
||||||
|
let sub_condition = expression.into_iter().fold(Condition::any(), |cond, prop| {
|
||||||
|
cond.add(build_single_filter(prop))
|
||||||
|
});
|
||||||
|
|
||||||
|
all_cond.add(sub_condition)
|
||||||
|
} else {
|
||||||
|
all_cond
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn build_single_filter(property: FilterProperty) -> SimpleExpr {
|
||||||
|
match property {
|
||||||
|
FilterProperty::TagId(tag_filter) => build_tag_id_filter(tag_filter),
|
||||||
|
FilterProperty::TagWildcardIds(wildcard_filter) => {
|
||||||
|
build_tag_wildcard_ids_filter(wildcard_filter)
|
||||||
|
}
|
||||||
|
FilterProperty::ContentDescriptor(cd_filter) => build_content_descriptor_filter(cd_filter),
|
||||||
|
FilterProperty::TagCount(count_filter) => build_tag_count_filter(count_filter),
|
||||||
|
FilterProperty::FileProperty(property_filter) => {
|
||||||
|
build_file_property_filter(property_filter)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_tag_id_filter(filter: NegatableComparator<i64>) -> SimpleExpr {
|
||||||
|
match filter {
|
||||||
|
NegatableComparator::Is(tag_id) => content_descriptor::Column::Id.in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(content_descriptor_tag::Column::CdId))
|
||||||
|
.from(content_descriptor_tag::Entity)
|
||||||
|
.cond_where(content_descriptor_tag::Column::TagId.eq(tag_id))
|
||||||
|
.to_owned(),
|
||||||
|
),
|
||||||
|
NegatableComparator::IsNot(tag_id) => content_descriptor::Column::Id.not_in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(content_descriptor_tag::Column::CdId))
|
||||||
|
.from(content_descriptor_tag::Entity)
|
||||||
|
.cond_where(content_descriptor_tag::Column::TagId.eq(tag_id))
|
||||||
|
.to_owned(),
|
||||||
|
),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_tag_wildcard_ids_filter(filter: NegatableComparator<Vec<i64>>) -> SimpleExpr {
|
||||||
|
match filter {
|
||||||
|
NegatableComparator::Is(tag_ids) => content_descriptor::Column::Id.in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(content_descriptor_tag::Column::CdId))
|
||||||
|
.from(content_descriptor_tag::Entity)
|
||||||
|
.cond_where(content_descriptor_tag::Column::TagId.is_in(tag_ids))
|
||||||
|
.to_owned(),
|
||||||
|
),
|
||||||
|
NegatableComparator::IsNot(tag_ids) => content_descriptor::Column::Id.not_in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(content_descriptor_tag::Column::CdId))
|
||||||
|
.from(content_descriptor_tag::Entity)
|
||||||
|
.cond_where(content_descriptor_tag::Column::TagId.is_in(tag_ids))
|
||||||
|
.to_owned(),
|
||||||
|
),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_content_descriptor_filter(filter: NegatableComparator<Vec<u8>>) -> SimpleExpr {
|
||||||
|
match filter {
|
||||||
|
NegatableComparator::Is(cd) => content_descriptor::Column::Descriptor.eq(cd),
|
||||||
|
NegatableComparator::IsNot(cd) => content_descriptor::Column::Descriptor.ne(cd),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_tag_count_filter(filter: OrderingComparator<i64>) -> SimpleExpr {
|
||||||
|
let count_column = Alias::new("count");
|
||||||
|
let cd_id_column = Alias::new("cd_id");
|
||||||
|
|
||||||
|
let count_subquery = Query::select()
|
||||||
|
.expr_as(
|
||||||
|
Expr::col(content_descriptor_tag::Column::CdId),
|
||||||
|
cd_id_column.clone(),
|
||||||
|
)
|
||||||
|
.expr_as(
|
||||||
|
content_descriptor_tag::Column::TagId.count(),
|
||||||
|
count_column.clone(),
|
||||||
|
)
|
||||||
|
.from(content_descriptor_tag::Entity)
|
||||||
|
.group_by_col(cd_id_column.clone())
|
||||||
|
.to_owned();
|
||||||
|
|
||||||
|
let count_expression = apply_ordering_comparator!(Expr::col(count_column), filter);
|
||||||
|
|
||||||
|
content_descriptor::Column::Id.in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(cd_id_column))
|
||||||
|
.from_subquery(count_subquery, Alias::new("tag_counts"))
|
||||||
|
.cond_where(count_expression)
|
||||||
|
.to_owned(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn build_file_property_filter(property: FilterFileProperty) -> SimpleExpr {
|
||||||
|
match property {
|
||||||
|
FilterFileProperty::Id(id_filter) => build_file_id_filter(id_filter),
|
||||||
|
FilterFileProperty::Status(status_filter) => build_file_status_filter(status_filter),
|
||||||
|
FilterFileProperty::FileSize(size_filter) => {
|
||||||
|
build_file_metadata_filter(build_file_size_filter(size_filter))
|
||||||
|
}
|
||||||
|
FilterFileProperty::ImportedTime(time_filter) => {
|
||||||
|
build_file_metadata_filter(build_file_import_time_filter(time_filter))
|
||||||
|
}
|
||||||
|
FilterFileProperty::ChangedTime(time_filter) => {
|
||||||
|
build_file_metadata_filter(build_file_changed_time_filter(time_filter))
|
||||||
|
}
|
||||||
|
FilterFileProperty::CreatedTime(time_filter) => {
|
||||||
|
build_file_metadata_filter(build_file_created_time_filter(time_filter))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_id_filter(filter: NegatableComparator<i64>) -> SimpleExpr {
|
||||||
|
match filter {
|
||||||
|
NegatableComparator::Is(id) => file::Column::Id.eq(id),
|
||||||
|
NegatableComparator::IsNot(id) => file::Column::Id.ne(id),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_status_filter(filter: NegatableComparator<i64>) -> SimpleExpr {
|
||||||
|
match filter {
|
||||||
|
NegatableComparator::Is(status) => file::Column::Status.eq(status),
|
||||||
|
NegatableComparator::IsNot(status) => file::Column::Status.ne(status),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_metadata_filter(property_condition: SimpleExpr) -> SimpleExpr {
|
||||||
|
file::Column::Id.in_subquery(
|
||||||
|
Query::select()
|
||||||
|
.expr(Expr::col(file_metadata::Column::FileId))
|
||||||
|
.from(file_metadata::Entity)
|
||||||
|
.cond_where(property_condition)
|
||||||
|
.to_owned(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_size_filter(filter: OrderingComparator<i64>) -> SimpleExpr {
|
||||||
|
apply_ordering_comparator!(file_metadata::Column::Size, filter)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_import_time_filter(filter: OrderingComparator<NaiveDateTime>) -> SimpleExpr {
|
||||||
|
apply_ordering_comparator!(file_metadata::Column::ImportTime, filter)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_changed_time_filter(filter: OrderingComparator<NaiveDateTime>) -> SimpleExpr {
|
||||||
|
apply_ordering_comparator!(file_metadata::Column::ChangeTime, filter)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_file_created_time_filter(filter: OrderingComparator<NaiveDateTime>) -> SimpleExpr {
|
||||||
|
apply_ordering_comparator!(file_metadata::Column::CreationTime, filter)
|
||||||
|
}
|
||||||
@ -0,0 +1,334 @@
|
|||||||
|
pub mod filter;
|
||||||
|
|
||||||
|
use std::fmt::Debug;
|
||||||
|
use std::io::Cursor;
|
||||||
|
use std::str::FromStr;
|
||||||
|
|
||||||
|
use mediarepo_core::content_descriptor::encode_content_descriptor;
|
||||||
|
use sea_orm::prelude::*;
|
||||||
|
use sea_orm::{ConnectionTrait, DatabaseConnection, Set};
|
||||||
|
use sea_orm::{JoinType, QuerySelect};
|
||||||
|
use tokio::io::{AsyncReadExt, BufReader};
|
||||||
|
|
||||||
|
use crate::file::filter::FilterProperty;
|
||||||
|
use crate::file_metadata::FileMetadata;
|
||||||
|
use mediarepo_core::error::{RepoError, RepoResult};
|
||||||
|
use mediarepo_core::fs::file_hash_store::FileHashStore;
|
||||||
|
use mediarepo_core::mediarepo_api::types::files::FileStatus as ApiFileStatus;
|
||||||
|
use mediarepo_core::thumbnailer::{self, Thumbnail as ThumbnailerThumb, ThumbnailSize};
|
||||||
|
use mediarepo_database::entities::content_descriptor;
|
||||||
|
use mediarepo_database::entities::content_descriptor_tag;
|
||||||
|
use mediarepo_database::entities::file;
|
||||||
|
use mediarepo_database::entities::file_metadata;
|
||||||
|
use mediarepo_database::entities::namespace;
|
||||||
|
use mediarepo_database::entities::tag;
|
||||||
|
|
||||||
|
use crate::tag::Tag;
|
||||||
|
|
||||||
|
pub enum FileStatus {
|
||||||
|
Imported = 10,
|
||||||
|
Archived = 20,
|
||||||
|
Deleted = 30,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<ApiFileStatus> for FileStatus {
|
||||||
|
fn from(s: ApiFileStatus) -> Self {
|
||||||
|
match s {
|
||||||
|
ApiFileStatus::Imported => Self::Imported,
|
||||||
|
ApiFileStatus::Archived => Self::Archived,
|
||||||
|
ApiFileStatus::Deleted => Self::Deleted,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct File {
|
||||||
|
db: DatabaseConnection,
|
||||||
|
model: file::Model,
|
||||||
|
content_descriptor: content_descriptor::Model,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl File {
|
||||||
|
#[tracing::instrument(level = "trace")]
|
||||||
|
pub(crate) fn new(
|
||||||
|
db: DatabaseConnection,
|
||||||
|
model: file::Model,
|
||||||
|
hash: content_descriptor::Model,
|
||||||
|
) -> Self {
|
||||||
|
Self {
|
||||||
|
db,
|
||||||
|
model,
|
||||||
|
content_descriptor: hash,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a list of all known stored files
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub async fn all(db: DatabaseConnection) -> RepoResult<Vec<File>> {
|
||||||
|
let files: Vec<(file::Model, Option<content_descriptor::Model>)> = file::Entity::find()
|
||||||
|
.find_also_related(content_descriptor::Entity)
|
||||||
|
.all(&db)
|
||||||
|
.await?;
|
||||||
|
let files = files
|
||||||
|
.into_iter()
|
||||||
|
.filter_map(|(f, h)| {
|
||||||
|
let h = h?;
|
||||||
|
Some(Self::new(db.clone(), f, h))
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
Ok(files)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fetches the file by id
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub async fn by_id(db: DatabaseConnection, id: i64) -> RepoResult<Option<Self>> {
|
||||||
|
if let Some((model, Some(hash))) = file::Entity::find_by_id(id)
|
||||||
|
.find_also_related(content_descriptor::Entity)
|
||||||
|
.one(&db)
|
||||||
|
.await?
|
||||||
|
{
|
||||||
|
let file = File::new(db, model, hash);
|
||||||
|
Ok(Some(file))
|
||||||
|
} else {
|
||||||
|
Ok(None)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Finds the file by hash
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub async fn by_cd(db: DatabaseConnection, cd: &[u8]) -> RepoResult<Option<Self>> {
|
||||||
|
if let Some((hash, Some(model))) = content_descriptor::Entity::find()
|
||||||
|
.filter(content_descriptor::Column::Descriptor.eq(cd))
|
||||||
|
.find_also_related(file::Entity)
|
||||||
|
.one(&db)
|
||||||
|
.await?
|
||||||
|
{
|
||||||
|
let file = File::new(db, model, hash);
|
||||||
|
Ok(Some(file))
|
||||||
|
} else {
|
||||||
|
Ok(None)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Finds the file by tags
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub(crate) async fn find_by_filters(
|
||||||
|
db: DatabaseConnection,
|
||||||
|
filters: Vec<Vec<FilterProperty>>,
|
||||||
|
) -> RepoResult<Vec<Self>> {
|
||||||
|
let main_condition = filter::build_find_filter_conditions(filters);
|
||||||
|
|
||||||
|
let results: Vec<(content_descriptor::Model, Option<file::Model>)> =
|
||||||
|
content_descriptor::Entity::find()
|
||||||
|
.find_also_related(file::Entity)
|
||||||
|
.filter(main_condition)
|
||||||
|
.group_by(file::Column::Id)
|
||||||
|
.all(&db)
|
||||||
|
.await?;
|
||||||
|
let files: Vec<Self> = results
|
||||||
|
.into_iter()
|
||||||
|
.filter_map(|(hash, tag)| Some(Self::new(db.clone(), tag?, hash)))
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
Ok(files)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adds a file with its hash to the database
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub(crate) async fn add(
|
||||||
|
db: DatabaseConnection,
|
||||||
|
cd_id: i64,
|
||||||
|
mime_type: String,
|
||||||
|
) -> RepoResult<Self> {
|
||||||
|
let file = file::ActiveModel {
|
||||||
|
cd_id: Set(cd_id),
|
||||||
|
mime_type: Set(mime_type),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
let file: file::ActiveModel = file.insert(&db).await?.into();
|
||||||
|
let file = Self::by_id(db, file.id.unwrap())
|
||||||
|
.await?
|
||||||
|
.expect("Inserted file does not exist");
|
||||||
|
|
||||||
|
Ok(file)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the unique identifier of the file
|
||||||
|
pub fn id(&self) -> i64 {
|
||||||
|
self.model.id
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the hash of the file (content identifier)
|
||||||
|
pub fn cd(&self) -> &[u8] {
|
||||||
|
&self.content_descriptor.descriptor
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the encoded content descriptor
|
||||||
|
pub fn encoded_cd(&self) -> String {
|
||||||
|
encode_content_descriptor(self.cd())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the id of the civ (content identifier value) of the file
|
||||||
|
pub fn cd_id(&self) -> i64 {
|
||||||
|
self.content_descriptor.id
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the mime type of the file
|
||||||
|
pub fn mime_type(&self) -> &String {
|
||||||
|
&self.model.mime_type
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the status of the file
|
||||||
|
pub fn status(&self) -> FileStatus {
|
||||||
|
match self.model.status {
|
||||||
|
10 => FileStatus::Imported,
|
||||||
|
20 => FileStatus::Archived,
|
||||||
|
30 => FileStatus::Deleted,
|
||||||
|
_ => FileStatus::Imported,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn set_status(&mut self, status: FileStatus) -> RepoResult<()> {
|
||||||
|
let active_model = file::ActiveModel {
|
||||||
|
id: Set(self.model.id),
|
||||||
|
status: Set(status as i32),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
self.model = active_model.update(&self.db).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the metadata associated with this file
|
||||||
|
/// A file MUST always have metadata associated
|
||||||
|
pub async fn metadata(&self) -> RepoResult<FileMetadata> {
|
||||||
|
FileMetadata::by_id(self.db.clone(), self.model.id)
|
||||||
|
.await
|
||||||
|
.and_then(|f| f.ok_or_else(|| RepoError::from("missing file metadata")))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the list of tags of the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn tags(&self) -> RepoResult<Vec<Tag>> {
|
||||||
|
let tags: Vec<(tag::Model, Option<namespace::Model>)> = tag::Entity::find()
|
||||||
|
.find_also_related(namespace::Entity)
|
||||||
|
.join(
|
||||||
|
JoinType::LeftJoin,
|
||||||
|
content_descriptor_tag::Relation::Tag.def().rev(),
|
||||||
|
)
|
||||||
|
.join(
|
||||||
|
JoinType::InnerJoin,
|
||||||
|
content_descriptor_tag::Relation::ContentDescriptorId.def(),
|
||||||
|
)
|
||||||
|
.filter(content_descriptor::Column::Id.eq(self.content_descriptor.id))
|
||||||
|
.all(&self.db)
|
||||||
|
.await?;
|
||||||
|
let tags = tags
|
||||||
|
.into_iter()
|
||||||
|
.map(|(tag, namespace)| Tag::new(self.db.clone(), tag, namespace))
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
Ok(tags)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adds a single tag to the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn add_tag(&mut self, tag_id: i64) -> RepoResult<()> {
|
||||||
|
let cd_id = self.content_descriptor.id;
|
||||||
|
let active_model = content_descriptor_tag::ActiveModel {
|
||||||
|
cd_id: Set(cd_id),
|
||||||
|
tag_id: Set(tag_id),
|
||||||
|
};
|
||||||
|
active_model.insert(&self.db).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adds multiple tags to the file at once
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn add_tags(&self, tag_ids: Vec<i64>) -> RepoResult<()> {
|
||||||
|
if tag_ids.is_empty() {
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
let cd_id = self.content_descriptor.id;
|
||||||
|
let models: Vec<content_descriptor_tag::ActiveModel> = tag_ids
|
||||||
|
.into_iter()
|
||||||
|
.map(|tag_id| content_descriptor_tag::ActiveModel {
|
||||||
|
cd_id: Set(cd_id),
|
||||||
|
tag_id: Set(tag_id),
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
content_descriptor_tag::Entity::insert_many(models)
|
||||||
|
.exec(&self.db)
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removes multiple tags from the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn remove_tags(&self, tag_ids: Vec<i64>) -> RepoResult<()> {
|
||||||
|
let hash_id = self.content_descriptor.id;
|
||||||
|
content_descriptor_tag::Entity::delete_many()
|
||||||
|
.filter(content_descriptor_tag::Column::CdId.eq(hash_id))
|
||||||
|
.filter(content_descriptor_tag::Column::TagId.is_in(tag_ids))
|
||||||
|
.exec(&self.db)
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the reader for the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn get_reader(
|
||||||
|
&self,
|
||||||
|
storage: &FileHashStore,
|
||||||
|
) -> RepoResult<BufReader<tokio::fs::File>> {
|
||||||
|
storage
|
||||||
|
.get_file(&self.content_descriptor.descriptor)
|
||||||
|
.await
|
||||||
|
.map(|(_, f)| f)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a thumbnail for the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn create_thumbnail<I: IntoIterator<Item = ThumbnailSize> + Debug>(
|
||||||
|
&self,
|
||||||
|
storage: &FileHashStore,
|
||||||
|
sizes: I,
|
||||||
|
) -> RepoResult<Vec<ThumbnailerThumb>> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
self.get_reader(storage)
|
||||||
|
.await?
|
||||||
|
.read_to_end(&mut buf)
|
||||||
|
.await?;
|
||||||
|
let mime_type = self.model.mime_type.clone();
|
||||||
|
let mime_type =
|
||||||
|
mime::Mime::from_str(&mime_type).unwrap_or_else(|_| mime::APPLICATION_OCTET_STREAM);
|
||||||
|
let thumbs = thumbnailer::create_thumbnails(Cursor::new(buf), mime_type, sizes)?;
|
||||||
|
|
||||||
|
Ok(thumbs)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Deletes the file as well as the content descriptor, tag mappings and metadata about the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn delete(self) -> RepoResult<()> {
|
||||||
|
let trx = self.db.begin().await?;
|
||||||
|
file_metadata::Entity::delete_many()
|
||||||
|
.filter(file_metadata::Column::FileId.eq(self.model.id))
|
||||||
|
.exec(&trx)
|
||||||
|
.await?;
|
||||||
|
self.model.delete(&trx).await?;
|
||||||
|
content_descriptor_tag::Entity::delete_many()
|
||||||
|
.filter(content_descriptor_tag::Column::CdId.eq(self.content_descriptor.id))
|
||||||
|
.exec(&trx)
|
||||||
|
.await?;
|
||||||
|
content_descriptor::Entity::delete_many()
|
||||||
|
.filter(content_descriptor::Column::Id.eq(self.content_descriptor.id))
|
||||||
|
.exec(&trx)
|
||||||
|
.await?;
|
||||||
|
trx.commit().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,124 @@
|
|||||||
|
use std::fmt::Debug;
|
||||||
|
|
||||||
|
use chrono::{Local, NaiveDateTime};
|
||||||
|
use sea_orm::prelude::*;
|
||||||
|
use sea_orm::{DatabaseConnection, Set};
|
||||||
|
|
||||||
|
use mediarepo_core::error::RepoResult;
|
||||||
|
use mediarepo_database::entities::file_metadata;
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct FileMetadata {
|
||||||
|
db: DatabaseConnection,
|
||||||
|
model: file_metadata::Model,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FileMetadata {
|
||||||
|
#[tracing::instrument(level = "trace")]
|
||||||
|
pub(crate) fn new(db: DatabaseConnection, model: file_metadata::Model) -> Self {
|
||||||
|
Self { db, model }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fetches the file by id
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub async fn by_id(db: DatabaseConnection, id: i64) -> RepoResult<Option<Self>> {
|
||||||
|
let file_metadata = file_metadata::Entity::find_by_id(id)
|
||||||
|
.one(&db)
|
||||||
|
.await?
|
||||||
|
.map(|m| FileMetadata::new(db, m));
|
||||||
|
|
||||||
|
Ok(file_metadata)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fetches metadata for all given file ids
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub async fn all_by_ids(db: DatabaseConnection, ids: Vec<i64>) -> RepoResult<Vec<Self>> {
|
||||||
|
let file_metadata = file_metadata::Entity::find()
|
||||||
|
.filter(file_metadata::Column::FileId.is_in(ids))
|
||||||
|
.all(&db)
|
||||||
|
.await?
|
||||||
|
.into_iter()
|
||||||
|
.map(|m| FileMetadata::new(db.clone(), m))
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
Ok(file_metadata)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adds a file with its hash to the database
|
||||||
|
#[tracing::instrument(level = "debug", skip(db))]
|
||||||
|
pub(crate) async fn add(
|
||||||
|
db: DatabaseConnection,
|
||||||
|
file_id: i64,
|
||||||
|
size: i64,
|
||||||
|
creation_time: NaiveDateTime,
|
||||||
|
change_time: NaiveDateTime,
|
||||||
|
) -> RepoResult<Self> {
|
||||||
|
let file = file_metadata::ActiveModel {
|
||||||
|
file_id: Set(file_id),
|
||||||
|
size: Set(size),
|
||||||
|
import_time: Set(Local::now().naive_local()),
|
||||||
|
creation_time: Set(creation_time),
|
||||||
|
change_time: Set(change_time),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
let model = file.insert(&db).await?;
|
||||||
|
|
||||||
|
Ok(Self::new(db, model))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn file_id(&self) -> i64 {
|
||||||
|
self.model.file_id
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn size(&self) -> i64 {
|
||||||
|
self.model.size
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn name(&self) -> &Option<String> {
|
||||||
|
&self.model.name
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn comment(&self) -> &Option<String> {
|
||||||
|
&self.model.comment
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn import_time(&self) -> &NaiveDateTime {
|
||||||
|
&self.model.import_time
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn creation_time(&self) -> &NaiveDateTime {
|
||||||
|
&self.model.creation_time
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn change_time(&self) -> &NaiveDateTime {
|
||||||
|
&self.model.change_time
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Changes the name of the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn set_name<S: ToString + Debug>(&mut self, name: S) -> RepoResult<()> {
|
||||||
|
let mut active_model = self.get_active_model();
|
||||||
|
active_model.name = Set(Some(name.to_string()));
|
||||||
|
self.model = active_model.update(&self.db).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Changes the comment of the file
|
||||||
|
#[tracing::instrument(level = "debug", skip(self))]
|
||||||
|
pub async fn set_comment<S: ToString + Debug>(&mut self, comment: S) -> RepoResult<()> {
|
||||||
|
let mut active_file = self.get_active_model();
|
||||||
|
active_file.comment = Set(Some(comment.to_string()));
|
||||||
|
self.model = active_file.update(&self.db).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the active model of the file with only the id set
|
||||||
|
fn get_active_model(&self) -> file_metadata::ActiveModel {
|
||||||
|
file_metadata::ActiveModel {
|
||||||
|
file_id: Set(self.file_id()),
|
||||||
|
..Default::default()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1,22 +0,0 @@
|
|||||||
use mime::Mime;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, Serialize, Deserialize, PartialOrd, PartialEq)]
|
|
||||||
pub enum FileType {
|
|
||||||
Other = -1,
|
|
||||||
Unknown = 0,
|
|
||||||
Image = 1,
|
|
||||||
Video = 2,
|
|
||||||
Audio = 3,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<Mime> for FileType {
|
|
||||||
fn from(mime_type: Mime) -> Self {
|
|
||||||
match mime_type.type_() {
|
|
||||||
mime::IMAGE => Self::Image,
|
|
||||||
mime::VIDEO => Self::Video,
|
|
||||||
mime::AUDIO => Self::Audio,
|
|
||||||
_ => Self::Other,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,16 +0,0 @@
|
|||||||
pub mod tag_handle;
|
|
||||||
|
|
||||||
use async_trait::async_trait;
|
|
||||||
use mediarepo_core::error::RepoResult;
|
|
||||||
use sea_orm::DatabaseConnection;
|
|
||||||
|
|
||||||
#[async_trait]
|
|
||||||
pub trait EntityHandle {
|
|
||||||
type Model;
|
|
||||||
|
|
||||||
/// Returns the ID that is stored in the handle
|
|
||||||
fn id(&self) -> i64;
|
|
||||||
|
|
||||||
/// Returns the model associated with the handle
|
|
||||||
async fn model(&self, db: DatabaseConnection) -> RepoResult<Self::Model>;
|
|
||||||
}
|
|
||||||
@ -1,24 +0,0 @@
|
|||||||
use crate::handles::EntityHandle;
|
|
||||||
use crate::tag::Tag;
|
|
||||||
use async_trait::async_trait;
|
|
||||||
use mediarepo_core::error::{RepoDatabaseError, RepoResult};
|
|
||||||
use sea_orm::DatabaseConnection;
|
|
||||||
|
|
||||||
pub struct TagHandle(pub(crate) i64);
|
|
||||||
|
|
||||||
#[async_trait]
|
|
||||||
impl EntityHandle for TagHandle {
|
|
||||||
type Model = Tag;
|
|
||||||
|
|
||||||
fn id(&self) -> i64 {
|
|
||||||
self.0
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn model(&self, db: DatabaseConnection) -> RepoResult<Self::Model> {
|
|
||||||
let tag = Tag::by_id(db, self.0)
|
|
||||||
.await?
|
|
||||||
.ok_or_else(|| RepoDatabaseError::InvalidHandle(self.id()))?;
|
|
||||||
|
|
||||||
Ok(tag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,10 +1,8 @@
|
|||||||
|
pub mod content_descriptor;
|
||||||
pub mod file;
|
pub mod file;
|
||||||
pub mod file_type;
|
pub mod file_metadata;
|
||||||
pub mod handles;
|
|
||||||
pub mod hash;
|
|
||||||
pub mod namespace;
|
pub mod namespace;
|
||||||
pub mod repo;
|
pub mod repo;
|
||||||
pub mod storage;
|
|
||||||
pub mod tag;
|
pub mod tag;
|
||||||
pub mod thumbnail;
|
pub mod thumbnail;
|
||||||
pub mod type_keys;
|
pub mod type_keys;
|
||||||
|
|||||||
@ -1,198 +0,0 @@
|
|||||||
use crate::hash::Hash;
|
|
||||||
use mediarepo_core::error::RepoResult;
|
|
||||||
use mediarepo_core::fs::file_hash_store::FileHashStore;
|
|
||||||
use mediarepo_database::entities::storage;
|
|
||||||
use mediarepo_database::entities::storage::ActiveModel as ActiveStorage;
|
|
||||||
use mediarepo_database::entities::storage::Model as StorageModel;
|
|
||||||
use sea_orm::prelude::*;
|
|
||||||
use sea_orm::{DatabaseConnection, NotSet, Set};
|
|
||||||
use std::fmt::Debug;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
use tokio::fs;
|
|
||||||
use tokio::io::{AsyncRead, BufReader};
|
|
||||||
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct Storage {
|
|
||||||
db: DatabaseConnection,
|
|
||||||
model: StorageModel,
|
|
||||||
store: FileHashStore,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Storage {
|
|
||||||
#[tracing::instrument(level = "trace")]
|
|
||||||
fn new(db: DatabaseConnection, model: StorageModel) -> Self {
|
|
||||||
let path = PathBuf::from(&model.path);
|
|
||||||
Self {
|
|
||||||
store: FileHashStore::new(path),
|
|
||||||
db,
|
|
||||||
model,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns all available storages
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn all(db: DatabaseConnection) -> RepoResult<Vec<Self>> {
|
|
||||||
let storages: Vec<storage::Model> = storage::Entity::find().all(&db).await?;
|
|
||||||
let storages = storages
|
|
||||||
.into_iter()
|
|
||||||
.map(|s| Self::new(db.clone(), s))
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
Ok(storages)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the storage by id
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn by_id(db: DatabaseConnection, id: i64) -> RepoResult<Option<Self>> {
|
|
||||||
if let Some(model) = storage::Entity::find_by_id(id).one(&db).await? {
|
|
||||||
let storage = Self::new(db, model);
|
|
||||||
Ok(Some(storage))
|
|
||||||
} else {
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the storage by name
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn by_name<S: AsRef<str> + Debug>(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
name: S,
|
|
||||||
) -> RepoResult<Option<Self>> {
|
|
||||||
if let Some(model) = storage::Entity::find()
|
|
||||||
.filter(storage::Column::Name.eq(name.as_ref()))
|
|
||||||
.one(&db)
|
|
||||||
.await?
|
|
||||||
{
|
|
||||||
let storage = Self::new(db, model);
|
|
||||||
Ok(Some(storage))
|
|
||||||
} else {
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the storage by path
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn by_path<S: ToString + Debug>(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
path: S,
|
|
||||||
) -> RepoResult<Option<Self>> {
|
|
||||||
if let Some(model) = storage::Entity::find()
|
|
||||||
.filter(storage::Column::Path.eq(path.to_string()))
|
|
||||||
.one(&db)
|
|
||||||
.await?
|
|
||||||
{
|
|
||||||
let storage = Self::new(db, model);
|
|
||||||
Ok(Some(storage))
|
|
||||||
} else {
|
|
||||||
Ok(None)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new active storage and also creates the associated directory
|
|
||||||
/// if it doesn't exist yet.
|
|
||||||
#[tracing::instrument(level = "debug", skip(db))]
|
|
||||||
pub async fn create<S1: ToString + Debug, S2: ToString + Debug>(
|
|
||||||
db: DatabaseConnection,
|
|
||||||
name: S1,
|
|
||||||
path: S2,
|
|
||||||
) -> RepoResult<Self> {
|
|
||||||
let path = path.to_string();
|
|
||||||
let name = name.to_string();
|
|
||||||
let path_buf = PathBuf::from(&path);
|
|
||||||
|
|
||||||
if !path_buf.exists() {
|
|
||||||
fs::create_dir(path_buf).await?;
|
|
||||||
}
|
|
||||||
let storage = ActiveStorage {
|
|
||||||
id: NotSet,
|
|
||||||
name: Set(name),
|
|
||||||
path: Set(path),
|
|
||||||
..Default::default()
|
|
||||||
};
|
|
||||||
let model = storage.insert(&db).await?;
|
|
||||||
|
|
||||||
Ok(Self::new(db, model))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the unique identifier of this storage
|
|
||||||
pub fn id(&self) -> i64 {
|
|
||||||
self.model.id
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the name of the storage
|
|
||||||
pub fn name(&self) -> &String {
|
|
||||||
&self.model.name
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the path of the storage
|
|
||||||
pub fn path(&self) -> &String {
|
|
||||||
&self.model.path
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets a new name for the storage
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn set_name<S: ToString + Debug>(&self, name: S) -> RepoResult<()> {
|
|
||||||
let mut active_storage: ActiveStorage = self.get_active_model();
|
|
||||||
active_storage.name = Set(name.to_string());
|
|
||||||
active_storage.update(&self.db).await?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets a new path for the storage. This will only update the database record
|
|
||||||
/// so if the physical part of the storage is already created it needs to be migrated first
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn set_path<S: ToString + Debug>(&mut self, path: S) -> RepoResult<()> {
|
|
||||||
let mut active_storage: ActiveStorage = self.get_active_model();
|
|
||||||
active_storage.path = Set(path.to_string());
|
|
||||||
let storage = active_storage.update(&self.db).await?;
|
|
||||||
|
|
||||||
self.model = storage;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Checks if the storage exists on the harddrive
|
|
||||||
pub fn exists(&self) -> bool {
|
|
||||||
let path = PathBuf::from(&self.path());
|
|
||||||
|
|
||||||
path.exists()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds a thumbnail
|
|
||||||
#[tracing::instrument(level = "debug", skip(self, reader))]
|
|
||||||
pub async fn store_entry<R: AsyncRead + Unpin>(&self, reader: R) -> RepoResult<Hash> {
|
|
||||||
let hash = self.store.add_file(reader, None).await?;
|
|
||||||
if let Some(hash) = Hash::by_value(self.db.clone(), &hash).await? {
|
|
||||||
Ok(hash)
|
|
||||||
} else {
|
|
||||||
Hash::add(self.db.clone(), hash).await
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the buf reader to the given hash
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn get_file_reader<S: ToString + Debug>(
|
|
||||||
&self,
|
|
||||||
hash: S,
|
|
||||||
) -> RepoResult<BufReader<tokio::fs::File>> {
|
|
||||||
let (_ext, reader) = self.store.get_file(hash.to_string()).await?;
|
|
||||||
|
|
||||||
Ok(reader)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the size of the storage
|
|
||||||
#[inline]
|
|
||||||
#[tracing::instrument(level = "debug", skip(self))]
|
|
||||||
pub async fn get_size(&self) -> RepoResult<u64> {
|
|
||||||
self.store.get_size().await
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the active model with only the ID filled so saves always perform an update
|
|
||||||
fn get_active_model(&self) -> ActiveStorage {
|
|
||||||
ActiveStorage {
|
|
||||||
id: Set(self.model.id),
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,185 @@
|
|||||||
|
use mediarepo_core::content_descriptor::decode_content_descriptor;
|
||||||
|
use mediarepo_core::error::RepoResult;
|
||||||
|
use mediarepo_core::mediarepo_api::types::files::FileStatus as ApiFileStatus;
|
||||||
|
use mediarepo_core::mediarepo_api::types::filtering::{
|
||||||
|
FilterExpression, FilterQuery, PropertyQuery, TagQuery, ValueComparator,
|
||||||
|
};
|
||||||
|
use mediarepo_model::file::filter::NegatableComparator::{Is, IsNot};
|
||||||
|
use mediarepo_model::file::filter::{FilterFileProperty, FilterProperty, OrderingComparator};
|
||||||
|
use mediarepo_model::file::{File, FileStatus};
|
||||||
|
use mediarepo_model::repo::Repo;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "debug", skip(repo))]
|
||||||
|
pub async fn find_files_for_filters(
|
||||||
|
repo: &Repo,
|
||||||
|
expressions: Vec<FilterExpression>,
|
||||||
|
) -> RepoResult<Vec<File>> {
|
||||||
|
let tag_names = get_tag_names_from_expressions(&expressions);
|
||||||
|
let tag_id_map = repo.tag_names_to_ids(tag_names).await?;
|
||||||
|
let filters = build_filters_from_expressions(expressions, &tag_id_map);
|
||||||
|
|
||||||
|
repo.find_files_by_filters(filters).await
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "debug")]
|
||||||
|
fn get_tag_names_from_expressions(expressions: &Vec<FilterExpression>) -> Vec<String> {
|
||||||
|
expressions
|
||||||
|
.iter()
|
||||||
|
.flat_map(|f| match f {
|
||||||
|
FilterExpression::OrExpression(queries) => queries
|
||||||
|
.iter()
|
||||||
|
.filter_map(|q| match q {
|
||||||
|
FilterQuery::Tag(tag) => Some(tag.tag.to_owned()),
|
||||||
|
_ => None,
|
||||||
|
})
|
||||||
|
.collect::<Vec<String>>(),
|
||||||
|
FilterExpression::Query(q) => match q {
|
||||||
|
FilterQuery::Tag(tag) => {
|
||||||
|
vec![tag.tag.to_owned()]
|
||||||
|
}
|
||||||
|
FilterQuery::Property(_) => {
|
||||||
|
vec![]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
})
|
||||||
|
.collect::<Vec<String>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "debug")]
|
||||||
|
fn build_filters_from_expressions(
|
||||||
|
expressions: Vec<FilterExpression>,
|
||||||
|
tag_id_map: &HashMap<String, i64>,
|
||||||
|
) -> Vec<Vec<FilterProperty>> {
|
||||||
|
expressions
|
||||||
|
.into_iter()
|
||||||
|
.filter_map(|e| {
|
||||||
|
let filters = match e {
|
||||||
|
FilterExpression::OrExpression(queries) => queries
|
||||||
|
.into_iter()
|
||||||
|
.filter_map(|q| map_query_to_filter(q, tag_id_map))
|
||||||
|
.collect(),
|
||||||
|
FilterExpression::Query(q) => {
|
||||||
|
if let Some(filter) = map_query_to_filter(q, tag_id_map) {
|
||||||
|
vec![filter]
|
||||||
|
} else {
|
||||||
|
vec![]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if filters.len() > 0 {
|
||||||
|
Some(filters)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn map_query_to_filter(
|
||||||
|
query: FilterQuery,
|
||||||
|
tag_id_map: &HashMap<String, i64>,
|
||||||
|
) -> Option<FilterProperty> {
|
||||||
|
match query {
|
||||||
|
FilterQuery::Tag(tag_query) => map_tag_query_to_filter(tag_query, tag_id_map),
|
||||||
|
FilterQuery::Property(property) => map_property_query_to_filter(property),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn map_tag_query_to_filter(
|
||||||
|
query: TagQuery,
|
||||||
|
tag_id_map: &HashMap<String, i64>,
|
||||||
|
) -> Option<FilterProperty> {
|
||||||
|
if query.tag.ends_with("*") {
|
||||||
|
map_wildcard_tag_to_filter(query, tag_id_map)
|
||||||
|
} else {
|
||||||
|
map_tag_to_filter(query, tag_id_map)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn map_wildcard_tag_to_filter(
|
||||||
|
query: TagQuery,
|
||||||
|
tag_id_map: &HashMap<String, i64>,
|
||||||
|
) -> Option<FilterProperty> {
|
||||||
|
let filter_tag = query.tag.trim_end_matches("*");
|
||||||
|
let relevant_ids = tag_id_map
|
||||||
|
.iter()
|
||||||
|
.filter_map(|(name, id)| {
|
||||||
|
if name.starts_with(filter_tag) {
|
||||||
|
Some(*id)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect::<Vec<i64>>();
|
||||||
|
|
||||||
|
if relevant_ids.len() > 0 {
|
||||||
|
let comparator = if query.negate {
|
||||||
|
IsNot(relevant_ids)
|
||||||
|
} else {
|
||||||
|
Is(relevant_ids)
|
||||||
|
};
|
||||||
|
Some(FilterProperty::TagWildcardIds(comparator))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn map_tag_to_filter(query: TagQuery, tag_id_map: &HashMap<String, i64>) -> Option<FilterProperty> {
|
||||||
|
tag_id_map.get(&query.tag).map(|id| {
|
||||||
|
let comparator = if query.negate { IsNot(*id) } else { Is(*id) };
|
||||||
|
FilterProperty::TagId(comparator)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn map_property_query_to_filter(query: PropertyQuery) -> Option<FilterProperty> {
|
||||||
|
match query {
|
||||||
|
PropertyQuery::Status(s) => Some(FilterProperty::FileProperty(FilterFileProperty::Status(
|
||||||
|
Is(file_status_to_number(s)),
|
||||||
|
))),
|
||||||
|
PropertyQuery::FileSize(s) => Some(FilterProperty::FileProperty(
|
||||||
|
FilterFileProperty::FileSize(val_comparator_to_order(s, |v| v as i64)),
|
||||||
|
)),
|
||||||
|
PropertyQuery::ImportedTime(t) => Some(FilterProperty::FileProperty(
|
||||||
|
FilterFileProperty::ImportedTime(val_comparator_to_order(t, |t| t)),
|
||||||
|
)),
|
||||||
|
PropertyQuery::ChangedTime(t) => Some(FilterProperty::FileProperty(
|
||||||
|
FilterFileProperty::ChangedTime(val_comparator_to_order(t, |t| t)),
|
||||||
|
)),
|
||||||
|
PropertyQuery::CreatedTime(t) => Some(FilterProperty::FileProperty(
|
||||||
|
FilterFileProperty::CreatedTime(val_comparator_to_order(t, |t| t)),
|
||||||
|
)),
|
||||||
|
PropertyQuery::TagCount(c) => {
|
||||||
|
Some(FilterProperty::TagCount(val_comparator_to_order(c, |v| {
|
||||||
|
v as i64
|
||||||
|
})))
|
||||||
|
}
|
||||||
|
PropertyQuery::Cd(cd) => decode_content_descriptor(cd)
|
||||||
|
.ok()
|
||||||
|
.map(|cd| FilterProperty::ContentDescriptor(Is(cd))),
|
||||||
|
PropertyQuery::Id(id) => Some(FilterProperty::FileProperty(FilterFileProperty::Id(Is(id)))),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn file_status_to_number(status: ApiFileStatus) -> i64 {
|
||||||
|
match status {
|
||||||
|
ApiFileStatus::Imported => FileStatus::Imported as i64,
|
||||||
|
ApiFileStatus::Archived => FileStatus::Archived as i64,
|
||||||
|
ApiFileStatus::Deleted => FileStatus::Deleted as i64,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn val_comparator_to_order<T1, T2, F: Fn(T1) -> T2>(
|
||||||
|
comp: ValueComparator<T1>,
|
||||||
|
conv_fn: F,
|
||||||
|
) -> OrderingComparator<T2> {
|
||||||
|
match comp {
|
||||||
|
ValueComparator::Less(v) => OrderingComparator::Less(conv_fn(v)),
|
||||||
|
ValueComparator::Equal(v) => OrderingComparator::Equal(conv_fn(v)),
|
||||||
|
ValueComparator::Greater(v) => OrderingComparator::Greater(conv_fn(v)),
|
||||||
|
ValueComparator::Between((v1, v2)) => {
|
||||||
|
OrderingComparator::Between((conv_fn(v1), conv_fn(v2)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,193 @@
|
|||||||
|
use chrono::NaiveDateTime;
|
||||||
|
use compare::Compare;
|
||||||
|
use mediarepo_core::error::RepoResult;
|
||||||
|
use mediarepo_core::mediarepo_api::types::filtering::{SortDirection, SortKey};
|
||||||
|
use mediarepo_database::queries::tags::{
|
||||||
|
get_cids_with_namespaced_tags, get_content_descriptors_with_tag_count,
|
||||||
|
};
|
||||||
|
use mediarepo_model::file::File;
|
||||||
|
use mediarepo_model::file_metadata::FileMetadata;
|
||||||
|
use mediarepo_model::repo::Repo;
|
||||||
|
use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
|
||||||
|
use std::cmp::Ordering;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::iter::FromIterator;
|
||||||
|
|
||||||
|
pub struct FileSortContext {
|
||||||
|
name: Option<String>,
|
||||||
|
size: u64,
|
||||||
|
mime_type: String,
|
||||||
|
namespaces: HashMap<String, Vec<String>>,
|
||||||
|
tag_count: u32,
|
||||||
|
import_time: NaiveDateTime,
|
||||||
|
create_time: NaiveDateTime,
|
||||||
|
change_time: NaiveDateTime,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "debug", skip(repo, files))]
|
||||||
|
pub async fn sort_files_by_properties(
|
||||||
|
repo: &Repo,
|
||||||
|
sort_expression: Vec<SortKey>,
|
||||||
|
files: &mut Vec<File>,
|
||||||
|
) -> RepoResult<()> {
|
||||||
|
let contexts = build_sort_context(repo, files).await?;
|
||||||
|
|
||||||
|
files.sort_by(|a, b| {
|
||||||
|
compare_files(
|
||||||
|
contexts.get(&a.id()).unwrap(),
|
||||||
|
contexts.get(&b.id()).unwrap(),
|
||||||
|
&sort_expression,
|
||||||
|
)
|
||||||
|
});
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn build_sort_context(
|
||||||
|
repo: &Repo,
|
||||||
|
files: &Vec<File>,
|
||||||
|
) -> RepoResult<HashMap<i64, FileSortContext>> {
|
||||||
|
let hash_ids: Vec<i64> = files.par_iter().map(|f| f.cd_id()).collect();
|
||||||
|
let file_ids: Vec<i64> = files.par_iter().map(|f| f.id()).collect();
|
||||||
|
|
||||||
|
let mut cid_nsp: HashMap<i64, HashMap<String, Vec<String>>> =
|
||||||
|
get_cids_with_namespaced_tags(repo.db(), hash_ids.clone()).await?;
|
||||||
|
let mut cid_tag_counts = get_content_descriptors_with_tag_count(repo.db(), hash_ids).await?;
|
||||||
|
|
||||||
|
let files_metadata = repo.get_file_metadata_for_ids(file_ids).await?;
|
||||||
|
|
||||||
|
let mut file_metadata_map: HashMap<i64, FileMetadata> =
|
||||||
|
HashMap::from_iter(files_metadata.into_iter().map(|m| (m.file_id(), m)));
|
||||||
|
|
||||||
|
let mut contexts = HashMap::new();
|
||||||
|
|
||||||
|
for file in files {
|
||||||
|
if let Some(metadata) = file_metadata_map.remove(&file.id()) {
|
||||||
|
let context = FileSortContext {
|
||||||
|
name: metadata.name().to_owned(),
|
||||||
|
size: metadata.size() as u64,
|
||||||
|
mime_type: file.mime_type().to_owned(),
|
||||||
|
namespaces: cid_nsp
|
||||||
|
.remove(&file.cd_id())
|
||||||
|
.unwrap_or(HashMap::with_capacity(0)),
|
||||||
|
tag_count: cid_tag_counts.remove(&file.cd_id()).unwrap_or(0),
|
||||||
|
import_time: metadata.import_time().to_owned(),
|
||||||
|
create_time: metadata.import_time().to_owned(),
|
||||||
|
change_time: metadata.change_time().to_owned(),
|
||||||
|
};
|
||||||
|
contexts.insert(file.id(), context);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(contexts)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tracing::instrument(level = "trace", skip_all)]
|
||||||
|
fn compare_files(
|
||||||
|
ctx_a: &FileSortContext,
|
||||||
|
ctx_b: &FileSortContext,
|
||||||
|
expression: &Vec<SortKey>,
|
||||||
|
) -> Ordering {
|
||||||
|
let cmp_date = compare::natural();
|
||||||
|
let cmp_u64 = compare::natural();
|
||||||
|
let cmp_u32 = compare::natural();
|
||||||
|
|
||||||
|
for sort_key in expression {
|
||||||
|
let ordering = match sort_key {
|
||||||
|
SortKey::Namespace(namespace) => {
|
||||||
|
let list_a = ctx_a.namespaces.get(&namespace.name);
|
||||||
|
let list_b = ctx_b.namespaces.get(&namespace.name);
|
||||||
|
|
||||||
|
let cmp_result = if let (Some(list_a), Some(list_b)) = (list_a, list_b) {
|
||||||
|
compare_tag_lists(list_a, list_b)
|
||||||
|
} else if list_a.is_some() {
|
||||||
|
Ordering::Greater
|
||||||
|
} else if list_b.is_some() {
|
||||||
|
Ordering::Less
|
||||||
|
} else {
|
||||||
|
Ordering::Equal
|
||||||
|
};
|
||||||
|
adjust_for_dir(cmp_result, &namespace.direction)
|
||||||
|
}
|
||||||
|
SortKey::FileName(direction) => {
|
||||||
|
adjust_for_dir(compare_opts(&ctx_a.name, &ctx_b.name), direction)
|
||||||
|
}
|
||||||
|
SortKey::FileSize(direction) => {
|
||||||
|
adjust_for_dir(cmp_u64.compare(&ctx_a.size, &ctx_b.size), direction)
|
||||||
|
}
|
||||||
|
SortKey::FileImportedTime(direction) => adjust_for_dir(
|
||||||
|
cmp_date.compare(&ctx_a.import_time, &ctx_b.import_time),
|
||||||
|
direction,
|
||||||
|
),
|
||||||
|
SortKey::FileCreatedTime(direction) => adjust_for_dir(
|
||||||
|
cmp_date.compare(&ctx_a.create_time, &ctx_b.create_time),
|
||||||
|
direction,
|
||||||
|
),
|
||||||
|
SortKey::FileChangeTime(direction) => adjust_for_dir(
|
||||||
|
cmp_date.compare(&ctx_a.change_time, &ctx_b.change_time),
|
||||||
|
direction,
|
||||||
|
),
|
||||||
|
SortKey::FileType(direction) => {
|
||||||
|
adjust_for_dir(ctx_a.mime_type.cmp(&ctx_b.mime_type), direction)
|
||||||
|
}
|
||||||
|
SortKey::NumTags(direction) => adjust_for_dir(
|
||||||
|
cmp_u32.compare(&ctx_a.tag_count, &ctx_b.tag_count),
|
||||||
|
direction,
|
||||||
|
),
|
||||||
|
};
|
||||||
|
if !ordering.is_eq() {
|
||||||
|
return ordering;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ordering::Equal
|
||||||
|
}
|
||||||
|
|
||||||
|
fn compare_opts<T: Ord + Sized>(opt_a: &Option<T>, opt_b: &Option<T>) -> Ordering {
|
||||||
|
let cmp = compare::natural();
|
||||||
|
if let (Some(a), Some(b)) = (opt_a, opt_b) {
|
||||||
|
cmp.compare(a, b)
|
||||||
|
} else if opt_a.is_some() {
|
||||||
|
Ordering::Greater
|
||||||
|
} else if opt_b.is_some() {
|
||||||
|
Ordering::Less
|
||||||
|
} else {
|
||||||
|
Ordering::Equal
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn compare_f32(a: f32, b: f32) -> Ordering {
|
||||||
|
if a > b {
|
||||||
|
Ordering::Greater
|
||||||
|
} else if b > a {
|
||||||
|
Ordering::Less
|
||||||
|
} else {
|
||||||
|
Ordering::Equal
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn adjust_for_dir(ordering: Ordering, direction: &SortDirection) -> Ordering {
|
||||||
|
if *direction == SortDirection::Descending {
|
||||||
|
ordering.reverse()
|
||||||
|
} else {
|
||||||
|
ordering
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn compare_tag_lists(list_a: &Vec<String>, list_b: &Vec<String>) -> Ordering {
|
||||||
|
let first_diff = list_a
|
||||||
|
.into_iter()
|
||||||
|
.zip(list_b.into_iter())
|
||||||
|
.find(|(a, b)| *a != *b);
|
||||||
|
if let Some(diff) = first_diff {
|
||||||
|
if let (Some(num_a), Some(num_b)) = (diff.0.parse::<f32>().ok(), diff.1.parse::<f32>().ok())
|
||||||
|
{
|
||||||
|
compare_f32(num_a, num_b)
|
||||||
|
} else {
|
||||||
|
let cmp = compare::natural();
|
||||||
|
cmp.compare(diff.0, diff.1)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Ordering::Equal
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,55 @@
|
|||||||
|
use crate::utils::{calculate_size, get_repo_from_context};
|
||||||
|
use mediarepo_core::bromine::prelude::*;
|
||||||
|
use mediarepo_core::error::RepoResult;
|
||||||
|
use mediarepo_core::mediarepo_api::types::jobs::{JobType, RunJobRequest};
|
||||||
|
use mediarepo_core::mediarepo_api::types::repo::SizeType;
|
||||||
|
use mediarepo_core::type_keys::SizeMetadataKey;
|
||||||
|
|
||||||
|
pub struct JobsNamespace;
|
||||||
|
|
||||||
|
impl NamespaceProvider for JobsNamespace {
|
||||||
|
fn name() -> &'static str {
|
||||||
|
"jobs"
|
||||||
|
}
|
||||||
|
|
||||||
|
fn register(handler: &mut EventHandler) {
|
||||||
|
events!(handler,
|
||||||
|
"run_job" => Self::run_job
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl JobsNamespace {
|
||||||
|
#[tracing::instrument(skip_all)]
|
||||||
|
pub async fn run_job(ctx: &Context, event: Event) -> IPCResult<()> {
|
||||||
|
let run_request = event.payload::<RunJobRequest>()?;
|
||||||
|
let repo = get_repo_from_context(ctx).await;
|
||||||
|
|
||||||
|
match run_request.job_type {
|
||||||
|
JobType::MigrateContentDescriptors => repo.migrate().await?,
|
||||||
|
JobType::CalculateSizes => calculate_all_sizes(ctx).await?,
|
||||||
|
JobType::CheckIntegrity => {}
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.emit_to(Self::name(), "run_job", ()).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn calculate_all_sizes(ctx: &Context) -> RepoResult<()> {
|
||||||
|
let size_types = vec![
|
||||||
|
SizeType::Total,
|
||||||
|
SizeType::FileFolder,
|
||||||
|
SizeType::ThumbFolder,
|
||||||
|
SizeType::DatabaseFile,
|
||||||
|
];
|
||||||
|
for size_type in size_types {
|
||||||
|
let size = calculate_size(&size_type, ctx).await?;
|
||||||
|
let mut data = ctx.data.write().await;
|
||||||
|
let size_map = data.get_mut::<SizeMetadataKey>().unwrap();
|
||||||
|
size_map.insert(size_type, size);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
@ -1,5 +0,0 @@
|
|||||||
pub static SETTINGS_PATH: &str = "./repo.toml";
|
|
||||||
pub static DEFAULT_STORAGE_NAME: &str = "Main";
|
|
||||||
pub static DEFAULT_STORAGE_PATH: &str = "files";
|
|
||||||
pub static THUMBNAIL_STORAGE_NAME: &str = "Thumbnails";
|
|
||||||
pub static THUMBNAIL_STORAGE_PATH: &str = "./thumbnails";
|
|
||||||
Loading…
Reference in New Issue