[IMP] server: check presence of required field in record (wip)

Author: fda-odoo

server/src/core/python_arch_eval_hooks.rs

@@ -874,6 +874,8 @@ impl PythonArchEvalHooks {
             "related",
             "compute",
             "delegate",
+            "required",
+            "default",
         ];
         contexts_to_add.extend(
             context_arguments.into_iter()
@@ -893,6 +895,9 @@ impl PythonArchEvalHooks {
                 if let Some(boolean) = maybe_boolean {
                     context.insert(S!(arg_name), ContextValue::BOOLEAN(boolean));
                 }
+                if arg_name == "default" {
+                    context.insert(S!("default"), ContextValue::BOOLEAN(true)); //set to True as the value is not really useful for now, but we want the key in context if one default is set
+                }
             }
         }
 

server/src/core/python_odoo_builder.rs

@@ -69,7 +69,11 @@ impl PythonOdooBuilder {
                             end: 1,
                         }),
                         xml_id: Some(xml_id_model_name),
-                        fields: vec![]
+                        fields: vec![],
+                        range: std::ops::Range::<usize> {
+                            start: self.symbol.borrow().range().start().to_usize(),
+                            end: self.symbol.borrow().range().end().to_usize(),
+                        }
                     }));
                 });
                 session.sync_odoo.models.insert(model_name.clone(), Rc::new(RefCell::new(model)));

server/src/core/xml_arch_builder_rng_validation.rs

@@ -244,7 +244,11 @@ impl XmlArchBuilder {
             file_symbol: Rc::downgrade(&self.xml_symbol),
             model: (oyarn!("{}", node.attribute("model").unwrap()), node.attribute_node("model").unwrap().range()),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
-            fields: vec![]
+            fields: vec![],
+            range: std::ops::Range::<usize> {
+                start: node.range().start as usize,
+                end: node.range().end as usize,
+            }
         };
         for child in node.children().filter(|n| n.is_element()) {
             if let Some(field) = self.load_field(session, &child, diagnostics) {

server/src/core/xml_data.rs

@@ -21,6 +21,7 @@ pub struct XmlDataRecord {
     pub model: (OYarn, Range<usize>),
     pub xml_id: Option<OYarn>,
     pub fields: Vec<XmlDataField>,
+    pub range: Range<usize>,
 }
 
 #[derive(Debug, Clone)]

server/src/core/xml_validation.rs

@@ -3,7 +3,7 @@ use std::{cell::RefCell, collections::HashMap, hash::Hash, path::PathBuf, rc::Rc
 use lsp_types::{Diagnostic, Position, Range};
 use tracing::{info, trace};
 
-use crate::{constants::{BuildSteps, SymType, DEBUG_STEPS, EXTENSION_NAME}, core::{entry_point::{EntryPoint, EntryPointType}, file_mgr::FileInfo, model::Model, odoo::SyncOdoo, symbols::symbol::Symbol, xml_data::{XmlData, XmlDataActWindow, XmlDataDelete, XmlDataMenuItem, XmlDataRecord, XmlDataReport, XmlDataTemplate}}, threads::SessionInfo, S};
+use crate::{constants::{BuildSteps, SymType, DEBUG_STEPS, EXTENSION_NAME}, core::{entry_point::{EntryPoint, EntryPointType}, evaluation::ContextValue, file_mgr::FileInfo, model::Model, odoo::SyncOdoo, symbols::symbol::Symbol, xml_data::{XmlData, XmlDataActWindow, XmlDataDelete, XmlDataMenuItem, XmlDataRecord, XmlDataReport, XmlDataTemplate}}, threads::SessionInfo, S};
 
 
 
@@ -89,9 +89,30 @@ impl XmlValidator {
             dependencies.push(main_sym.borrow().get_file().unwrap().upgrade().unwrap());
         }
         let all_fields = Symbol::all_fields(&main_symbols[0], session, Some(module.clone()));
+        let mut mandatory_fields: Vec<String> = vec![];
+        // for (field_name, field_sym) in all_fields.iter() {
+        //     for (fs, deps) in field_sym.iter() {
+        //         if deps.is_none() {
+        //             let has_required = fs.borrow().evaluations().unwrap_or(&vec![]).iter()
+        //             .any(|eval| 
+        //                 eval.symbol.get_symbol_as_weak(session, &mut None, diagnostics, None)
+        //                 .context.get("required").unwrap_or(&ContextValue::BOOLEAN(false)).as_bool()
+        //             );
+        //             let has_default = fs.borrow().evaluations().unwrap_or(&vec![]).iter()
+        //             .any(|eval| 
+        //                 eval.symbol.get_symbol_as_weak(session, &mut None, diagnostics, None)
+        //                 .context.contains_key("default")
+        //             );
+        //             if has_required && !has_default {
+        //                 mandatory_fields.push(field_name.clone());
+        //             }
+        //         }
+        //     }
+        // }
         for field in &xml_data_record.fields {
             let declared_field = all_fields.get(&field.name);
             if let Some(declared_field) = declared_field {
+                mandatory_fields.retain(|f| f != &field.name);
                 //TODO Check type
             } else {
 
@@ -106,6 +127,17 @@ impl XmlValidator {
                 ));
             }
         }
+        // if mandatory_fields.len() > 0 {
+        //         diagnostics.push(Diagnostic::new(
+        //             Range::new(Position::new(xml_data_record.range.start.try_into().unwrap(), 0), Position::new(xml_data_record.range.end.try_into().unwrap(), 0)),
+        //             Some(lsp_types::DiagnosticSeverity::ERROR),
+        //             Some(lsp_types::NumberOrString::String(S!("OLS30452"))),
+        //             Some(EXTENSION_NAME.to_string()),
+        //             format!("Some mandatory fields are not declared in the record: {:?}", mandatory_fields),
+        //             None,
+        //             None
+        //         ));
+        // }
     }
 
     fn validate_menu_item(&self, session: &mut SessionInfo, module: &Rc<RefCell<Symbol>>, xml_data_menu_item: &XmlDataMenuItem, diagnostics: &mut Vec<Diagnostic>, dependencies: &mut Vec<Rc<RefCell<Symbol>>>, model_dependencies: &mut Vec<Rc<RefCell<Model>>>) {