Skip to main content

max / audiofiles

7.5 KB · 264 lines History Blame Raw
1 //! `DirectBackend` library structure: VFS create/rename/delete, directory
2 //! listing (plain and analysis-enriched), tags, and collections.
3
4 use super::{
5 BackendResult, Collection, CollectionBackend, CollectionId, DirectBackend, NodeId,
6 SearchFilter, TagBackend, Vfs, VfsBackend, VfsId, VfsNode, VfsNodeWithAnalysis, collections,
7 instrument, tags, vfs,
8 };
9
10 impl VfsBackend for DirectBackend {
11 // --- VFS ---
12
13 fn list_vfs(&self) -> BackendResult<Vec<Vfs>> {
14 let db = self.db.lock();
15 Ok(vfs::list_vfs(&db)?)
16 }
17
18 #[instrument(skip(self))]
19 fn create_vfs(&self, name: &str) -> BackendResult<VfsId> {
20 let db = self.db.lock();
21 Ok(vfs::create_vfs(&db, name)?)
22 }
23
24 #[instrument(skip(self))]
25 fn rename_vfs(&self, id: VfsId, new_name: &str) -> BackendResult<()> {
26 let db = self.db.lock();
27 Ok(vfs::rename_vfs(&db, id, new_name)?)
28 }
29
30 #[instrument(skip(self))]
31 fn delete_vfs(&self, id: VfsId) -> BackendResult<()> {
32 let db = self.db.lock();
33 Ok(vfs::delete_vfs(&db, id)?)
34 }
35
36 fn list_children_enriched(
37 &self,
38 vfs_id: VfsId,
39 parent_id: Option<NodeId>,
40 ) -> BackendResult<Vec<VfsNodeWithAnalysis>> {
41 let db = self.db.lock();
42 Ok(vfs::list_children_enriched(&db, vfs_id, parent_id)?)
43 }
44
45 fn list_children(
46 &self,
47 vfs_id: VfsId,
48 parent_id: Option<NodeId>,
49 ) -> BackendResult<Vec<VfsNode>> {
50 let db = self.db.lock();
51 Ok(vfs::list_children(&db, vfs_id, parent_id)?)
52 }
53
54 #[instrument(skip(self))]
55 fn create_directory(
56 &self,
57 vfs_id: VfsId,
58 parent_id: Option<NodeId>,
59 name: &str,
60 ) -> BackendResult<NodeId> {
61 let db = self.db.lock();
62 Ok(vfs::create_directory(&db, vfs_id, parent_id, name)?)
63 }
64
65 #[instrument(skip(self))]
66 fn create_sample_link(
67 &self,
68 vfs_id: VfsId,
69 parent_id: Option<NodeId>,
70 name: &str,
71 sample_hash: &str,
72 ) -> BackendResult<NodeId> {
73 let db = self.db.lock();
74 Ok(vfs::create_sample_link(
75 &db,
76 vfs_id,
77 parent_id,
78 name,
79 sample_hash,
80 )?)
81 }
82
83 fn get_node(&self, id: NodeId) -> BackendResult<VfsNode> {
84 let db = self.db.lock();
85 Ok(vfs::get_node(&db, id)?)
86 }
87
88 fn get_breadcrumb(&self, node_id: NodeId) -> BackendResult<Vec<VfsNode>> {
89 let db = self.db.lock();
90 Ok(vfs::get_breadcrumb(&db, node_id)?)
91 }
92
93 #[instrument(skip(self))]
94 fn rename_node(&self, id: NodeId, new_name: &str) -> BackendResult<()> {
95 let db = self.db.lock();
96 Ok(vfs::rename_node(&db, id, new_name)?)
97 }
98
99 #[instrument(skip(self))]
100 fn move_node(&self, id: NodeId, new_parent_id: Option<NodeId>) -> BackendResult<()> {
101 let db = self.db.lock();
102 Ok(vfs::move_node(&db, id, new_parent_id)?)
103 }
104
105 #[instrument(skip(self))]
106 fn delete_node(&self, id: NodeId) -> BackendResult<()> {
107 let db = self.db.lock();
108 Ok(vfs::delete_node(&db, id)?)
109 }
110
111 #[instrument(skip_all)]
112 fn restore_node(&self, node: &VfsNode) -> BackendResult<()> {
113 let db = self.db.lock();
114 Ok(vfs::restore_node(&db, node)?)
115 }
116
117 fn collect_subtree(&self, node_id: NodeId) -> BackendResult<Vec<VfsNode>> {
118 let db = self.db.lock();
119 Ok(vfs::collect_subtree(&db, node_id)?)
120 }
121
122 fn list_all_directories(&self, vfs_id: VfsId) -> BackendResult<Vec<(NodeId, String)>> {
123 let db = self.db.lock();
124 Ok(vfs::list_all_directories(&db, vfs_id)?)
125 }
126
127 fn find_nodes_by_hashes(
128 &self,
129 vfs_id: VfsId,
130 hashes: &[&str],
131 ) -> BackendResult<Vec<VfsNodeWithAnalysis>> {
132 let db = self.db.lock();
133 Ok(vfs::find_nodes_by_hashes(&db, vfs_id, hashes)?)
134 }
135 }
136
137 impl TagBackend for DirectBackend {
138 // --- Tags ---
139
140 #[instrument(skip(self))]
141 fn add_tag(&self, hash: &str, tag: &str) -> BackendResult<()> {
142 let db = self.db.lock();
143 Ok(tags::add_tag(&db, hash, tag)?)
144 }
145
146 #[instrument(skip(self))]
147 fn remove_tag(&self, hash: &str, tag: &str) -> BackendResult<()> {
148 let db = self.db.lock();
149 Ok(tags::remove_tag(&db, hash, tag)?)
150 }
151
152 fn get_sample_tags(&self, hash: &str) -> BackendResult<Vec<String>> {
153 let db = self.db.lock();
154 Ok(tags::get_sample_tags(&db, hash)?)
155 }
156
157 fn list_all_tags(&self) -> BackendResult<Vec<String>> {
158 let db = self.db.lock();
159 Ok(tags::list_all_tags(&db)?)
160 }
161
162 #[instrument(skip(self, hashes))]
163 fn bulk_add_tag(&self, hashes: &[&str], tag: &str) -> BackendResult<usize> {
164 let db = self.db.lock();
165 Ok(tags::bulk_add_tag(&db, hashes, tag)?)
166 }
167
168 #[instrument(skip(self, hashes))]
169 fn bulk_remove_tag(&self, hashes: &[&str], tag: &str) -> BackendResult<usize> {
170 let db = self.db.lock();
171 Ok(tags::bulk_remove_tag(&db, hashes, tag)?)
172 }
173
174 fn rename_tag_globally(&self, old_tag: &str, new_tag: &str) -> BackendResult<usize> {
175 let db = self.db.lock();
176 Ok(tags::rename_tag_globally(&db, old_tag, new_tag)?)
177 }
178
179 fn count_samples_with_tag(&self, tag: &str) -> BackendResult<usize> {
180 let db = self.db.lock();
181 Ok(tags::find_by_tag(&db, tag)?.len())
182 }
183
184 fn remove_tag_globally(&self, tag: &str) -> BackendResult<usize> {
185 let db = self.db.lock();
186 Ok(tags::remove_tag_globally(&db, tag)?)
187 }
188 }
189
190 impl CollectionBackend for DirectBackend {
191 // --- Collections ---
192
193 fn list_collections(&self) -> BackendResult<Vec<Collection>> {
194 let db = self.db.lock();
195 Ok(collections::list_collections(&db)?)
196 }
197
198 #[instrument(skip(self))]
199 fn create_collection(
200 &self,
201 name: &str,
202 description: Option<&str>,
203 ) -> BackendResult<CollectionId> {
204 let db = self.db.lock();
205 Ok(collections::create_collection(&db, name, description)?)
206 }
207
208 fn create_dynamic_collection(
209 &self,
210 name: &str,
211 filter: &SearchFilter,
212 ) -> BackendResult<CollectionId> {
213 let db = self.db.lock();
214 Ok(collections::create_dynamic_collection(&db, name, filter)?)
215 }
216
217 fn rename_collection(&self, id: CollectionId, new_name: &str) -> BackendResult<()> {
218 let db = self.db.lock();
219 Ok(collections::rename_collection(&db, id, new_name)?)
220 }
221
222 #[instrument(skip(self))]
223 fn delete_collection(&self, id: CollectionId) -> BackendResult<()> {
224 let db = self.db.lock();
225 Ok(collections::delete_collection(&db, id)?)
226 }
227
228 fn add_to_collection(
229 &self,
230 collection_id: CollectionId,
231 sample_hash: &str,
232 ) -> BackendResult<()> {
233 let db = self.db.lock();
234 Ok(collections::add_to_collection(
235 &db,
236 collection_id,
237 sample_hash,
238 )?)
239 }
240
241 fn remove_from_collection(
242 &self,
243 collection_id: CollectionId,
244 sample_hash: &str,
245 ) -> BackendResult<()> {
246 let db = self.db.lock();
247 Ok(collections::remove_from_collection(
248 &db,
249 collection_id,
250 sample_hash,
251 )?)
252 }
253
254 fn list_collection_members(&self, collection_id: CollectionId) -> BackendResult<Vec<String>> {
255 let db = self.db.lock();
256 Ok(collections::list_collection_members(&db, collection_id)?)
257 }
258
259 fn get_sample_collections(&self, sample_hash: &str) -> BackendResult<Vec<Collection>> {
260 let db = self.db.lock();
261 Ok(collections::get_sample_collections(&db, sample_hash)?)
262 }
263 }
264