hvmd 0.1.0

productivity tool for those who need it the most
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::process::exit;

use sea_orm::ActiveValue::Set;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
use uuid::Uuid;

use crate::db::db;

use super::model::{ActiveModel, Column, Entity as Asset, Model};
use super::{CreateTask, EditTask};

pub async fn insert(create_asset: CreateTask) -> String {
	let db = &db().await;
	let asset: ActiveModel = ActiveModel {
		id: Set(Uuid::new_v4()),
		title: Set(create_asset.title),
		description: Set(create_asset.description),
		completed: Set(create_asset.completed.unwrap_or_default()),
		..Default::default()
	};

	match asset.insert(db).await {
		Ok(row) => row.id.to_string(),
		Err(e) => {
			eprintln!("{}", e);
			exit(1);
		}
	}
}

pub async fn update(edit_asset: EditTask) -> String {
	let db = &db().await;
	match Asset::find_by_id(edit_asset.id).one(db).await {
		Ok(row) => match row {
			Some(row) => {
				let mut asset: super::model::ActiveModel = row.into();

				if let Some(title) = edit_asset.title {
					asset.title = Set(title);
				}
				if let Some(description) = edit_asset.description {
					asset.description = Set(Some(description));
				}
				if let Some(completed) = edit_asset.completed {
					asset.completed = Set(completed);
				}

				match asset.update(db).await {
					Ok(new_row) => new_row.id.to_string(),
					Err(e) => {
						eprintln!("{}", e);
						exit(1);
					}
				}
			}
			None => {
				eprintln!("could not find asset of #{}", edit_asset.id);
				exit(1);
			}
		},
		Err(e) => {
			eprintln!("{}", e);
			exit(1);
		}
	}
}

pub async fn get(id: Uuid) -> Option<Model> {
	match Asset::find_by_id(id).one(&db().await).await {
		Ok(asset) => asset,
		Err(e) => {
			eprintln!("{}", e);
			exit(1);
		}
	}
}

pub async fn list() -> Vec<Model> {
	match Asset::find()
		.order_by_desc(Column::UpdatedAt)
		.all(&db().await)
		.await
	{
		Ok(assets) => assets,
		Err(e) => {
			eprintln!("{}", e);
			exit(1);
		}
	}
}

pub async fn list_by_completed(completed: bool) -> Vec<Model> {
	match Asset::find()
		.order_by_desc(Column::UpdatedAt)
		.filter(Column::Completed.eq(completed))
		.all(&db().await)
		.await
	{
		Ok(assets) => assets,
		Err(e) => {
			eprintln!("{}", e);
			exit(1);
		}
	}
}