store build logs in db

endpoint to get logs
checks if pkg already in db force build flag

src/api/add.rs

@@ -1,12 +1,14 @@
 use crate::aur::aur::get_info_by_name;
 use crate::builder::types::Action;
+use crate::db::prelude::{Packages, Versions};
 use crate::db::{packages, versions};
+use rocket::response::status::NotFound;
 use rocket::serde::json::Json;
 use rocket::serde::Deserialize;
 use rocket::{post, State};
 use rocket_okapi::okapi::schemars;
 use rocket_okapi::{openapi, JsonSchema};
-use sea_orm::ActiveModelTrait;
+use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter};
 use sea_orm::{DatabaseConnection, Set};
 use tokio::sync::broadcast::Sender;
 
@@ -14,6 +16,7 @@ use tokio::sync::broadcast::Sender;
 #[serde(crate = "rocket::serde")]
 pub struct AddBody {
     name: String,
+    force_build: bool,
 }
 
 #[openapi(tag = "test")]
@@ -22,29 +25,56 @@ pub async fn package_add(
     db: &State<DatabaseConnection>,
     input: Json<AddBody>,
     tx: &State<Sender<Action>>,
-) -> Result<(), String> {
+) -> Result<(), NotFound<String>> {
     let db = db as &DatabaseConnection;
-    let pkg_name = &input.name;
 
-    let pkg = get_info_by_name(pkg_name)
+    let pkt_model = match Packages::find()
+        .filter(packages::Column::Name.eq(input.name.clone()))
+        .one(db)
         .await
-        .map_err(|_| "couldn't download package metadata".to_string())?;
+        .map_err(|e| NotFound(e.to_string()))?
+    {
+        None => {
+            let new_package = packages::ActiveModel {
+                name: Set(input.name.clone()),
+                ..Default::default()
+            };
 
-    let new_package = packages::ActiveModel {
-        name: Set(pkg_name.clone()),
-        ..Default::default()
+            new_package.save(db).await.expect("TODO: panic message")
+        }
+        Some(p) => p.into(),
     };
 
-    let pkt_model = new_package.save(db).await.expect("TODO: panic message");
+    let pkg = get_info_by_name(input.name.clone().as_str())
+        .await
+        .map_err(|_| NotFound("couldn't download package metadata".to_string()))?;
 
-    let new_version = versions::ActiveModel {
-        version: Set(pkg.version.clone()),
-        package_id: Set(pkt_model.id.clone().unwrap()),
-        ..Default::default()
+    let version_model = match Versions::find()
+        .filter(versions::Column::Version.eq(pkg.version.clone()))
+        .one(db)
+        .await
+        .map_err(|e| NotFound(e.to_string()))?
+    {
+        None => {
+            let new_version = versions::ActiveModel {
+                version: Set(pkg.version.clone()),
+                package_id: Set(pkt_model.id.clone().unwrap()),
+                ..Default::default()
+            };
+
+            new_version.save(db).await.expect("TODO: panic message")
+        }
+        Some(p) => {
+            // todo add check if this version was successfully built
+            // if not allow build
+            if input.force_build {
+                p.into()
+            } else {
+                return Err(NotFound("Version already existing".to_string()));
+            }
+        }
     };
 
-    let version_model = new_version.save(db).await.expect("TODO: panic message");
-
     let _ = tx.send(Action::Build(
         pkg.name,
         pkg.version,