ready na kodenie

src/lib.rs

@@ -1,4 +1,2 @@
 // src/lib.rs
 
-pub mod logic;
-pub use logic::Kniznica;

src/logic.rs

@@ -1,166 +0,0 @@
-// src/logic.rs
-
-use serde::{Deserialize, Serialize};
-use std::fmt;
-
-#[derive(Default, Serialize, Deserialize, PartialEq)]
-pub enum Stav {
-    #[default] Nova = 0,
-    Pouzivana = 1,
-    Poskodena = 2,
-    Vyradena = 3,
-}
-
-impl fmt::Display for Stav {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Stav::Nova => write!(f, "Nova"),
-            Stav::Pouzivana => write!(f, "Pouzivana"),
-            Stav::Poskodena => write!(f, "Poskodena"),
-            Stav::Vyradena => write!(f, "Vyradena")
-        }
-    }
-}
-
-#[derive(Default, Serialize, Deserialize)]
-pub struct Kniha {
-    autori: Vec<String>,
-    nazov: String,
-    vydavatelstvo: String,
-    zaner: String,
-    pocet_stran: usize,
-    isbn: String,
-    rok_vydania: usize,
-    je_pozicana: bool,
-    stav_knihy: Stav,
-}
-
-impl fmt::Display for Kniha {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "(Autori: {},
-               Nazov: {},
-               Vydavatelstvo: {},
-               Zaner: {},
-               Pocet stran: {},
-               ISBN: {},
-               Rok vydania: {},
-               Je pozicana {},
-               Stav knihy: {})",
-               self.autori.join(", "),
-               self.nazov,
-               self.vydavatelstvo,
-               self.zaner,
-               self.pocet_stran,
-               self.isbn,
-               self.rok_vydania,
-               self.je_pozicana,
-               self.stav_knihy,
-        )
-    }
-}
-
-
-#[derive(Default, Serialize, Deserialize)]
-pub struct Kniznica {
-    knihy: Vec<Kniha>
-}
-
-impl Kniznica {
-    // Asociovana funkcia
-    pub fn nacitaj_zo_suboru(cesta: &std::path::PathBuf) -> Option<Self>{
-        let obsah = match std::fs::read_to_string(cesta) {
-            Ok(text) => text,
-            Err(_) => return None,
-        };
-        let kniznica = match serde_json::from_str(obsah.as_str()) {
-            Ok(k) => k,
-            Err(_) => return None,
-        };
-        Some(kniznica)
-    }
-    // Metoda
-    pub fn uloz_do_suboru(&self, cesta: &std::path::PathBuf) -> bool {
-        let converted = match serde_json::to_string(&self) {
-            Ok(k) => k,
-            Err(_) => return false,
-        };
-        match std::fs::write(cesta, converted) {
-            Ok(_) => return true,
-            Err(_) => return false,
-        };
-    }
-
-    pub fn pridaj_knihu(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
-        for x in &self.knihy {
-            if x.isbn == nova_kniha.isbn {
-                return Err(());
-            }
-        }
-        self.knihy.push(nova_kniha);
-        Ok(())
-    }
-
-    pub fn pridaj_knihu2(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
-        let moze = self.knihy.iter()
-                             .all(|x| x.isbn != nova_kniha.isbn);
-        if moze {
-            self.knihy.push(nova_kniha);
-        } else {
-            return Err(());
-        }
-        Ok(())
-    }
-
-    pub fn odstran_knihu(&mut self, isbn: &str) -> Result<Kniha, ()> {
-        if let Some(index) = self.knihy.iter()
-            .position(|x| x.isbn == isbn) {
-                let kniha = self.knihy.remove(index);
-                Ok(kniha)
-            } else {
-                Err(())
-            }
-
-    }
-
-    pub fn daj_knihu_podla_isbn(&self, isbn: &str) -> Option<&Kniha> {
-        if let Some(vrat) = self.knihy.iter().find(|x| x.isbn == isbn) {
-            return Some(vrat);
-        }
-        None
-    }
-
-    pub fn daj_knihy_podla_autora(&self, autor: &str) -> Vec<&Kniha> {
-        let vrat: Vec<&Kniha>= self.knihy.iter().filter(|x| x.autori.contains(&autor.to_string())).collect();
-        vrat
-    }
-
-    pub fn daj_knihy_podla_stavu(&self, stav_knihy: Stav) -> Vec<&Kniha> {
-       self.knihy.iter().filter(|x| x.stav_knihy == stav_knihy).collect()
-    }
-
-    pub fn vypis_vydavatelstva_a_pocet_knih(&self) {
-        // hashmap obsahuje <K, V> kde K moze byt string a V pocet
-        let mut mapa = std::collections::HashMap::new();
-        for k in &self.knihy {
-            let meno = &k.vydavatelstvo;
-
-            let novy_pocet = match mapa.get(meno) {
-                Some(pocet) => pocet + 1,
-                None => 1,
-            };
-
-            mapa.insert(meno, novy_pocet);
-
-        }
-        for (vyd, pocet) in mapa {
-            println!("{}: {}", vyd, pocet);
-        }
-    }
-
-    pub fn vypis_knihy_daneho_zanru(&self, zaner_st: &str) {
-        let k: Vec<_> = self.knihy.iter().filter(|x| x.zaner == zaner_st).collect();
-        for x in k {
-            println!("{}", x);
-        }
-    }
-}

src/main.rs

@@ -1,93 +1,3 @@
-// src/main.rs
-use clap::{Parser, Subcommand};
-use priprava_na_skusku2::Kniznica;
-use std::path::PathBuf;
-
-#[derive(Parser)]
-#[command(name= "KniznicaApp")]
-struct Cli {
-    #[command(subcommand)] 
-    command: Commands,
-}
-
-#[derive(Subcommand)] 
-enum Commands {
-    DajKnihuIsbn {
-        #[arg(short, long)]
-        cesta: std::path::PathBuf,
-        #[arg(short, long)]
-        isbn: String,
-    },
-    DajKnihyAutora {
-        #[arg(short, long)]
-        cesta: std::path::PathBuf,
-        #[arg(short, long)]
-        autor: String,
-    },
-    OdstranKnihu {
-        #[arg(short, long)]
-        cesta: std::path::PathBuf,
-        #[arg(short, long)]
-        isbn: String,
-    },
-    VypisVydavatelstva {
-        #[arg(short, long)]
-        cesta: std::path::PathBuf,
-    },
-}
-
 fn main() {
-    let args = Cli::parse();
+    println!("Hello, world!");
-    match args.command {
-        Commands::DajKnihuIsbn {cesta, isbn} => {
-            if let Some(kniznica) = Kniznica::nacitaj_zo_suboru(&cesta) {
-                if let Some(kniha) = kniznica.daj_knihu_podla_isbn(&isbn) {
-                    println!("Nájdená kniha: {}", kniha);
-                } else {
-                    println!("Kniha s ISBN {} sa nenašla.", isbn);
-                }
-            } else {
-                println!("Nepodarilo sa načítať súbor na ceste {:?}", cesta);
-            }
-        },
-        Commands::DajKnihyAutora {cesta, autor} => {
-            if let Some(kniznica) = Kniznica::nacitaj_zo_suboru(&cesta) {
-                let k_a= kniznica.daj_knihy_podla_autora(&autor);
-                for kniha in k_a {
-                    println!{"{}", kniha};
-                }
-
-            } else {
-                println!("Nepodarilo sa načítať subor {:?}", cesta);
-            }
-
-        },
-        Commands::OdstranKnihu {cesta, isbn} => {
-            if let Some(mut kniznica) = Kniznica::nacitaj_zo_suboru(&cesta) {
-                match kniznica.odstran_knihu(&isbn) {
-                    Ok(vymazana) => {
-                        println!("Úspešne odstránená kniha: {}", vymazana);
-                        if kniznica.uloz_do_suboru(&cesta) {
-                            println!("Zmeny boli uložené.");
-                        } else {
-                            println!("Chyba pri ukladaní súboru.");
-                        }
-                    },
-                    Err(_) => {
-                        println!("Kniha s ISBN {} nebola nájdená.", isbn);
-                    }
-                }
-            } else {
-                println!("Nepodarilo sa načítať subor {:?}", cesta);
-            }
-        },
-        Commands::VypisVydavatelstva {cesta} => {
-            if let Some(kniznica) = Kniznica::nacitaj_zo_suboru(&cesta) {
-                kniznica.vypis_vydavatelstva_a_pocet_knih();
-            } else {
-                println!("Nepodarilo sa načítať subor {:?}", cesta);
-            }
-
-        },
-    }
 }