use crate::prelude::*;
use r2d2::PooledConnection;
use r2d2_sqlite::SqliteConnectionManager;
use rusqlite::{params, Row};
use crate::persist::local::models::schema_models::Task;
pub type DbConn = PooledConnection<SqliteConnectionManager>;
#[derive(Clone, Debug)]
pub struct TaskRepo {
db: Arc<DatabaseService>,
}
impl TaskRepo {
pub fn new(db: Arc<DatabaseService>) -> Self {
Self { db }
}
}
impl Repository<Task> for TaskRepo {
fn get_connection(&self) -> Result<r2d2::PooledConnection<SqliteConnectionManager>> {
self.db.get_connection().map_err(Into::into)
}
fn map_row(row: &Row) -> Result<Task> {
let created_at_str: String = row
.get("created_at")
.map_err(|e| anyhow::anyhow!("{}", e))?;
let updated_at_str: String = row
.get("updated_at")
.map_err(|e| anyhow::anyhow!("{}", e))?;
let created_at = parse_timestamp(&created_at_str)?;
let updated_at = parse_timestamp(&updated_at_str)?;
let feature_ids_str: String = row
.get("feature_ids")
.map_err(|e| anyhow::anyhow!("{}", e))?;
let feature_id = if feature_ids_str.starts_with('[') {
feature_ids_str.trim_matches(['[', ']', '"']).to_string()
} else {
feature_ids_str
};
Ok(Task::from_db_row(
row.get("id").map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("project_id")
.map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("code").map_err(|e| anyhow::anyhow!("{}", e))?,
feature_id,
row.get("title").map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("priority").map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("status").map_err(|e| anyhow::anyhow!("{}", e))?,
row.get::<&str, Option<String>>("category")
.map_err(|e| anyhow::anyhow!("{}", e))?
.unwrap_or_default(),
row.get("depends_on")
.map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("assigned_to")
.map_err(|e| anyhow::anyhow!("{}", e))?,
row.get("notes").map_err(|e| anyhow::anyhow!("{}", e))?,
created_at,
updated_at,
)
.map_err(|e| anyhow::anyhow!("{}", e))?)
}
fn create_impl(
&self,
entity: &Task,
conn: &PooledConnection<SqliteConnectionManager>,
) -> Result<()> {
conn.execute(
r#"
INSERT INTO tasks (id, project_id, code, feature_ids, title, description, category, status, priority, assigned_to, depends_on, notes, created_at, updated_at)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)
"#,
params![
&entity.id,
&entity.project_id,
&entity.code,
&entity.feature_id,
&entity.task,
&entity.task,
&entity.category,
&entity.status,
&entity.priority,
&entity.assigned,
&entity.dependencies,
&entity.notes,
&entity.created_at.to_rfc3339(),
&entity.updated_at.to_rfc3339(),
],
).map_err(|e| anyhow::anyhow!("{}", e))?;
Ok(())
}
fn find_by_id_impl(
&self,
id: &str,
conn: &PooledConnection<SqliteConnectionManager>,
) -> Result<Option<Task>> {
let mut stmt = conn.prepare(
"SELECT id, project_id, code, feature_ids, title, category, status, priority, assigned_to, depends_on, notes, created_at, updated_at FROM tasks WHERE id = ?1",
).map_err(|e| anyhow::anyhow!("{}", e))?;
let mut rows = stmt
.query(params![id])
.map_err(|e| anyhow::anyhow!("{}", e))?;
if let Some(row) = rows.next().map_err(|e| anyhow::anyhow!("{}", e))? {
Ok(Some(Self::map_row(row)?))
} else {
Ok(None)
}
}
fn update_impl(
&self,
entity: &Task,
conn: &PooledConnection<SqliteConnectionManager>,
) -> Result<()> {
conn.execute(
r#"
UPDATE tasks SET title = ?1, description = ?2, status = ?3, priority = ?4, notes = ?5, updated_at = ?6
WHERE id = ?7
"#,
params![
&entity.task,
&entity.task,
&entity.status,
&entity.priority,
&entity.notes,
chrono::Utc::now().to_rfc3339(),
&entity.id,
],
).map_err(|e| anyhow::anyhow!("{}", e))?;
Ok(())
}
fn upsert_impl(
&self,
entity: &Task,
conn: &PooledConnection<SqliteConnectionManager>,
) -> Result<()> {
conn.execute(
r#"
INSERT OR REPLACE INTO tasks (id, project_id, code, feature_ids, title, description, category, status, priority, assigned_to, depends_on, notes, created_at, updated_at)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)
"#,
params![
&entity.id,
&entity.project_id,
&entity.code,
&entity.feature_id,
&entity.task,
&entity.task,
&entity.category,
&entity.status,
&entity.priority,
&entity.assigned,
&entity.dependencies,
&entity.notes,
&entity.created_at.to_rfc3339(),
&entity.updated_at.to_rfc3339(),
],
).map_err(|e| anyhow::anyhow!("{}", e))?;
Ok(())
}
fn delete_impl(
&self,
id: &str,
conn: &PooledConnection<SqliteConnectionManager>,
) -> Result<()> {
conn.execute("DELETE FROM tasks WHERE id = ?", params![id])
.map_err(|e| anyhow::anyhow!("{}", e))?;
Ok(())
}
fn list_impl(
&self,
conn: &PooledConnection<SqliteConnectionManager>,
_offset: Option<i64>,
_limit: Option<i64>,
) -> Result<Vec<Task>> {
let mut stmt = conn.prepare(
"SELECT id, project_id, code, feature_ids, title, category, status, priority, assigned_to, depends_on, notes, created_at, updated_at FROM tasks ORDER BY created_at DESC",
).map_err(|e| anyhow::anyhow!("{}", e))?;
let mut rows = stmt.query([]).map_err(|e| anyhow::anyhow!("{}", e))?;
let mut tasks = Vec::new();
while let Some(row) = rows.next().map_err(|e| anyhow::anyhow!("{}", e))? {
tasks.push(Self::map_row(row)?);
}
Ok(tasks)
}
fn count_impl(&self, conn: &PooledConnection<SqliteConnectionManager>) -> Result<i64> {
let count: i64 = conn
.query_row("SELECT COUNT(*) FROM tasks", [], |row| row.get(0))
.map_err(|e| anyhow::anyhow!("{}", e))?;
Ok(count)
}
}
fn parse_timestamp(s: &str) -> Result<chrono::DateTime<chrono::Utc>> {
if let Ok(parsed) = chrono::DateTime::parse_from_rfc3339(s) {
Ok(parsed.with_timezone(&chrono::Utc))
} else {
let parsed = chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")?;
Ok(parsed.and_utc())
}
}