chris/lumina
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

finishing video_model transition to sqlx

Browse source
This commit is contained in:
Chris Cochrun 2024-09-25 11:08:03 -05:00
parent df07b13b28
commit a697e4d89c
1 changed files with 127 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

224
src/rust/video_model.rs
View file

@ -180,7 +180,7 @@ mod video_model {
use cxx_qt::{CxxQtType, Threading}; use cxx_qt::{CxxQtType, Threading};
use cxx_qt_lib::{QByteArray, QModelIndex, QString, QUrl, QVariant}; use cxx_qt_lib::{QByteArray, QModelIndex, QString, QUrl, QVariant};
use sqlx::{query, query_as, SqliteConnection}; use sqlx::{query, query_as, Connection, SqliteConnection};
use std::path::PathBuf; use std::path::PathBuf;
use std::pin::Pin; use std::pin::Pin;
use tracing::{debug, error}; use tracing::{debug, error};
@ -256,7 +256,6 @@ impl video_model::VideoModel {
return false; return false;
} }
let video_id = self.videos.get(index as usize).unwrap().id; let video_id = self.videos.get(index as usize).unwrap().id;
let thread = self.qt_thread();
let rt = tokio::runtime::Runtime::new().unwrap(); let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async { rt.block_on(async {
@ -462,31 +461,39 @@ impl video_model::VideoModel {
let model_index = let model_index =
&self.as_ref().index(index, 0, &QModelIndex::default()); &self.as_ref().index(index, 0, &QModelIndex::default());
let db = &mut self.as_mut().get_db(); let rt = tokio::runtime::Runtime::new().unwrap();
let result = update(videos.filter(id.eq(index))) rt.block_on(async {
.set(end_time.eq(updated_end_time)) let result = query!("UPDATE videos SET endTime = ? where id = ?", updated_end_time, index)
.execute(db); .execute(&mut self.as_mut().rust_mut().db)
match result { .await;
Ok(_i) => { match result {
for video in self Ok(_i) => {
.as_mut() for video in self
.rust_mut() .as_mut()
.videos .rust_mut()
.iter_mut() .videos
.filter(|x| x.id == index) .iter_mut()
{ .filter(|x| x.id == index)
video.end_time = updated_end_time; {
video.end_time = updated_end_time;
debug!(title = video.title,
end_time = updated_end_time,
"updated video end_time");
}
self.as_mut().data_changed(
model_index,
model_index,
&vector_roles,
);
true
} }
self.as_mut().data_changed( Err(e) => {
model_index, error!("Error connecting to db: {e}");
model_index, false
&vector_roles, },
);
println!("rust-end-time: {updated_end_time:?}");
true
} }
Err(_e) => false, });
} true
} }
pub fn update_start_time( pub fn update_start_time(
@ -500,31 +507,39 @@ impl video_model::VideoModel {
let model_index = let model_index =
&self.as_ref().index(index, 0, &QModelIndex::default()); &self.as_ref().index(index, 0, &QModelIndex::default());
let db = &mut self.as_mut().get_db(); let rt = tokio::runtime::Runtime::new().unwrap();
let result = update(videos.filter(id.eq(index))) rt.block_on(async {
.set(start_time.eq(updated_start_time)) let result = query!("UPDATE videos SET startTime = ? where id = ?", updated_start_time, index)
.execute(db); .execute(&mut self.as_mut().rust_mut().db)
match result { .await;
Ok(_i) => { match result {
for video in self Ok(_i) => {
.as_mut() for video in self
.rust_mut() .as_mut()
.videos .rust_mut()
.iter_mut() .videos
.filter(|x| x.id == index) .iter_mut()
{ .filter(|x| x.id == index)
video.start_time = updated_start_time; {
video.start_time = updated_start_time;
debug!(title = video.title,
start_time = updated_start_time,
"updated video start_time");
}
self.as_mut().data_changed(
model_index,
model_index,
&vector_roles,
);
true
} }
self.as_mut().data_changed( Err(e) => {
model_index, error!("Error connecting to db: {e}");
model_index, false
&vector_roles, },
);
println!("rust-start-time: {:?}", updated_start_time);
true
} }
Err(_e) => false, });
} true
} }
pub fn update_title( pub fn update_title(
@ -538,33 +553,40 @@ impl video_model::VideoModel {
let model_index = let model_index =
&self.as_ref().index(index, 0, &QModelIndex::default()); &self.as_ref().index(index, 0, &QModelIndex::default());
let db = &mut self.as_mut().get_db(); let rt = tokio::runtime::Runtime::new().unwrap();
let result = update(videos.filter(id.eq(index))) rt.block_on(async {
.set(title.eq(updated_title.to_string())) let title = updated_title.to_string();
.execute(db); let result = query!("UPDATE videos SET title = ? where id = ?", title, index)
match result { .execute(&mut self.as_mut().rust_mut().db)
Ok(_i) => { .await;
for video in self match result {
.as_mut() Ok(_i) => {
.rust_mut() for video in self
.videos .as_mut()
.iter_mut() .rust_mut()
.filter(|x| x.id == index) .videos
{ .iter_mut()
video.title = updated_title.clone().to_string(); .filter(|x| x.id == index)
println!("rust-title: {:?}", video.title); {
video.title = title.clone();
debug!(title = video.title,
title = title,
"updated video title");
}
self.as_mut().data_changed(
model_index,
model_index,
&vector_roles,
);
true
} }
// TODO this seems to not be updating in the actual list Err(e) => {
self.as_mut().data_changed( error!("Error connecting to db: {e}");
model_index, false
model_index, },
&vector_roles,
);
println!("rust-title: {:?}", updated_title);
true
} }
Err(_e) => false, });
} true
} }
pub fn update_path( pub fn update_path(
@ -577,32 +599,40 @@ impl video_model::VideoModel {
let model_index = let model_index =
&self.as_ref().index(index, 0, &QModelIndex::default()); &self.as_ref().index(index, 0, &QModelIndex::default());
let db = &mut self.as_mut().get_db(); let rt = tokio::runtime::Runtime::new().unwrap();
let result = update(videos.filter(id.eq(index))) rt.block_on(async {
.set(path.eq(updated_path.to_string())) let updated_path = updated_path.to_string();
.execute(db); let result = query!("UPDATE videos SET filePath = ? where id = ?", updated_path, index)
match result { .execute(&mut self.as_mut().rust_mut().db)
Ok(_i) => { .await;
for video in self match result {
.as_mut() Ok(_i) => {
.rust_mut() for video in self
.videos .as_mut()
.iter_mut() .rust_mut()
.filter(|x| x.id == index) .videos
{ .iter_mut()
video.path = updated_path.clone().to_string(); .filter(|x| x.id == index)
println!("rust-title: {:?}", video.title); {
video.path = updated_path.clone();
debug!(title = video.title,
path = updated_path,
"updated video path");
}
self.as_mut().data_changed(
model_index,
model_index,
&vector_roles,
);
true
} }
self.as_mut().data_changed( Err(e) => {
model_index, error!("Error connecting to db: {e}");
model_index, false
&vector_roles, },
);
println!("rust-path: {:?}", updated_path);
true
} }
Err(_e) => false, });
} true
} }
fn search(mut self: Pin<&mut Self>, search_term: QString) { fn search(mut self: Pin<&mut Self>, search_term: QString) {