basic seving of new analytic unit config

server/src/services/analytic_service/analytic_service.rs

@@ -278,14 +278,10 @@ impl AnalyticService {
         let my_id = self.analytic_unit_service.get_config_id(&self.analytic_unit_config);
         let patch_id = patch.get_type_id();
 
-        println!("my id: {}", my_id);
-        println!("patch id: {}", patch_id);
-
-        println!("equals: {}", my_id == patch_id);
-
         let same_type = my_id == patch_id;
 
         if same_type {
+            // TODO: check when learning should be started
             let new_conf = patch.get_new_config();
             self.analytic_unit_config = new_conf.clone();
             self.analytic_unit_service.update_config_by_id(&my_id, &new_conf).unwrap();
@@ -304,11 +300,19 @@ impl AnalyticService {
                     }
                 });
             } else {
-                // TODO: implement
+                // TODO: check if we need this else
+                match tx.send(()) {
+                    Ok(_) => {}
+                    Err(_e) => {
+                        println!("Can`t send patch config notification");
+                    }
+                }
             }
         } else {
             // TODO: extracdt from db
-
+            let new_conf = self.analytic_unit_service.get_config_by_id(&patch_id).unwrap();
+            self.analytic_unit_config = new_conf.clone();
+            self.consume_request(RequestType::RunLearning);
             match tx.send(()) {
                 Ok(_) => {}
                 Err(_e) => {

server/src/services/analytic_service/analytic_unit/types.rs

@@ -57,12 +57,22 @@ impl Default for ThresholdConfig {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub enum AnalyticUnitConfig {
-    Pattern(PatternConfig),
     Threshold(ThresholdConfig),
+    Pattern(PatternConfig),
     Anomaly(AnomalyConfig),
 }
 
 impl AnalyticUnitConfig {
+
+    pub fn get_default_by_id(id: &String) -> AnalyticUnitConfig {
+        let iid = id.as_str();
+        match iid {
+            "1" => AnalyticUnitConfig::Threshold(Default::default()),
+            "2" => AnalyticUnitConfig::Pattern(Default::default()),
+            "3" => AnalyticUnitConfig::Anomaly(Default::default()),
+            _ => panic!("bad id for getting get_default_by_id")
+        }
+    }
     // return true if need needs relearning
     pub fn patch(&self, patch: PatchConfig) -> (AnalyticUnitConfig, bool) {
         match patch {

server/src/services/analytic_unit_service.rs

@@ -127,8 +127,31 @@ impl AnalyticUnitService {
         }
     }
 
-    pub fn get_config_by_id(&self) {
-        // TODO: implement
+    pub fn get_config_by_id(&self, id: &String) -> anyhow::Result<AnalyticUnitConfig> {
+        let exists = {
+            let conn = self.connection.lock().unwrap();
+            let mut stmt = conn.prepare(
+                "SELECT config from analytic_unit WHERE id = ?1"
+            )?;
+            stmt.exists([id])?
+        };
+
+        if exists == false {
+            let c = AnalyticUnitConfig::get_default_by_id(id);
+            self.resolve(&c)?;
+            return Ok(c);
+        } else {
+            let conn = self.connection.lock().unwrap();
+            let mut stmt = conn.prepare(
+                "SELECT config from analytic_unit WHERE id = ?1"
+            )?;
+            let acfg = stmt.query_row([id], |row| {
+                let c: String = row.get(0)?;
+                let cfg = serde_json::from_str(&c).unwrap();
+                Ok(cfg)
+            })?;
+            return Ok(acfg);
+        }
     }
 
     pub fn get_config_id(&self, cfg: &AnalyticUnitConfig) -> String {
@@ -140,6 +163,8 @@ impl AnalyticUnitService {
     }
 
     pub fn update_config_by_id(&self, id: &String, cfg: &AnalyticUnitConfig) -> anyhow::Result<()> {
+
+        // TODO: it's possble that config doesn't exist, but we trying to update it
         let conn = self.connection.lock().unwrap();
 
         let cfg_json = serde_json::to_string(&cfg)?;