Add skill import functionality and update database configuration

.gitignore

@@ -18,6 +18,7 @@ node_modules/
 *.pdb
 
 *.sqlite
+*.db
 
 uploads/
 assets/static/css/main.css

config/development.yaml

@@ -88,7 +88,7 @@ mailer:
 # Database Configuration
 database:
   # Database connection URI
-  uri: {{ get_env(name="DATABASE_URL", default="postgres://postgres:postgres@localhost:5432/gabrielkaszewski_rs") }}
+  uri: {{ get_env(name="DATABASE_URL", default="sqlite://./database.db") }}
   # When enabled, the sql query will be logged.
   enable_logging: false
   # Set the timeout duration when acquiring a connection.

migration/src/m20241110_011041_add_is_highlighted_to_project.rs

@@ -13,47 +13,26 @@ enum Projects {
 #[async_trait::async_trait]
 impl MigrationTrait for Migration {
     async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        //
-        // add column
-        //
         manager
             .alter_table(
                 Table::alter()
                     .table(Projects::Table)
                     .add_column_if_not_exists(boolean(Projects::IsHighlighted).default(false))
-                    .add_column_if_not_exists(boolean(Projects::IsArchived).default(false))
                     .to_owned(),
             )
-            .await
+            .await?;
 
-        //
-        // delete column
-        //
-        /*
+        // Add `is_archived` column
         manager
             .alter_table(
                 Table::alter()
-                    .table(Movies::Table)
-                    .drop_column(Movies::Rating)
+                    .table(Projects::Table)
+                    .add_column_if_not_exists(boolean(Projects::IsArchived).default(false))
                     .to_owned(),
             )
-            .await
-        */
+            .await?;
 
-        //
-        // create index
-        //
-        /*
-        manager
-            .create_index(
-                Index::create()
-                    .name("idx-movies-rating")
-                    .table(Movies::Table)
-                    .col(Movies::Rating)
-                    .to_owned(),
-            )
-            .await;
-        */
+        Ok(())
     }
 
     async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {

src/app.rs

@@ -78,6 +78,7 @@ impl Hooks for App {
         tasks.register(tasks::create_user::CreateUserData);
         tasks.register(tasks::create_job::CreateJobData);
         tasks.register(tasks::create_skill::CreateSkillData);
+        tasks.register(tasks::import_skills::ImportSkills);
         tasks.register(tasks::add_data_file::AddDataFile);
         tasks.register(tasks::delete_data::DeleteData);
         tasks.register(tasks::clear_data::ClearData);

src/services/skills.rs

@@ -1,7 +1,7 @@
 use loco_rs::prelude::*;
 use sea_orm::QueryOrder;
 
-use crate::models::_entities::skills::{Column, Entity, Model};
+use crate::models::_entities::skills::{ActiveModel, Column, Entity, Model};
 
 pub async fn get_all_skills(ctx: &AppContext) -> Result<Vec<Model>> {
     let skills = Entity::find()
@@ -9,3 +9,25 @@ pub async fn get_all_skills(ctx: &AppContext) -> Result<Vec<Model>> {
     .all(&ctx.db).await?;
     Ok(skills)
 }
+
+pub async fn add_skill(ctx: &AppContext, name: String) -> Result<Model> {
+    let new_skill = ActiveModel {
+        name: Set(name),
+        ..Default::default()
+    };
+    let new_skill = new_skill.insert(&ctx.db).await?;
+    Ok(new_skill)
+}
+
+pub async fn add_skills(ctx: &AppContext, skills: Vec<String>) -> Result<Vec<Model>> {
+    let mut new_skills = vec![];
+    for skill in skills {
+        let new_skill = ActiveModel {
+            name: Set(skill),
+            ..Default::default()
+        };
+        let new_skill = new_skill.insert(&ctx.db).await?;
+        new_skills.push(new_skill);
+    }
+    Ok(new_skills)
+}

src/tasks/create_skill.rs

@@ -1,6 +1,6 @@
 use loco_rs::prelude::*;
 
-use crate::models::_entities::skills::ActiveModel;
+use crate::services::skills::add_skill;
 
 pub struct CreateSkillData;
 
@@ -16,13 +16,7 @@ impl Task for CreateSkillData {
     async fn run(&self, app_context: &AppContext, vars: &task::Vars) -> Result<()> {
         let name = vars.cli_arg("name")?;
 
-        let mut item = ActiveModel {
-            ..Default::default()
-        };
-
-        item.name = Set(name.to_string());
-
-        let item = item.insert(&app_context.db).await?;
+        let item = add_skill(app_context, name.to_string()).await?;
 
         tracing::info!(
             skill_id = item.id,

src/tasks/import_skills.rs

@@ -0,0 +1,70 @@
+use loco_rs::prelude::*;
+use serde::Deserialize;
+
+use crate::services::skills::add_skills;
+
+pub struct ImportSkills;
+
+#[derive(Deserialize)]
+struct Skill {
+    name: String,
+}
+
+#[derive(Deserialize)]
+struct Skills {
+    skills: Vec<Skill>,
+}
+
+#[async_trait]
+impl Task for ImportSkills {
+    fn task(&self) -> TaskInfo {
+        TaskInfo {
+            name: "import_skills".to_string(),
+            detail: "Task for importing skills from json file or stdin".to_string(),
+        }
+    }
+
+    async fn run(&self, app_context: &AppContext, vars: &task::Vars) -> Result<()> {
+        let from_file = vars.cli_arg("from_file").ok().map(|v| v.parse::<bool>().unwrap_or(false)).unwrap_or(false);
+
+        match from_file {
+            true => {
+                let file_path = vars.cli_arg("file_path")?;
+
+                let data = std::fs::read_to_string(file_path)?;
+                let skills: Skills = serde_json::from_str(&data)?;
+                process_skills(app_context, skills).await?;
+
+                Ok(())
+            },
+            false => {
+                let raw_data = vars.cli_arg("raw_data")?;
+                let skills: Skills = get_skills_from_raw_data(&raw_data);
+                process_skills(app_context, skills).await?;
+
+                Ok(())
+            },
+        }
+        
+    }
+}
+
+fn get_skills_from_raw_data(raw_data: &str) -> Skills {
+    let skills = raw_data.split(',').map(|s| Skill { name: s.to_string() }).collect();
+    Skills { skills }
+}
+
+async fn process_skills(app_context: &AppContext, skills: Skills) -> Result<()> {
+    let skills_names = skills.skills.iter().map(|s| s.name.clone()).collect();
+    let items = add_skills(app_context, skills_names).await?;
+
+    for item in items {
+        tracing::info!(
+            skill_id = item.id,
+            skill_name = &item.name,
+            "Skill created successfully",
+        );
+    }
+
+    Ok(())
+}

src/tasks/mod.rs

@@ -6,3 +6,4 @@ pub mod seed;
 pub mod clear_data;
 pub mod delete_data;
 pub mod delete_project;
+pub mod import_skills;