Pulled from forlabs

src/errors/error_proxy.py

@@ -80,11 +80,14 @@ class error_proxy:
         else:
             self.error_text = ""
             
-                
-        
-        
-                    
-        
-        
-        
-        
+    @property        
+    def is_empty(self) -> bool:
+        """
+            Флаг. Есть ошибка
+        Returns:
+            bool: _description_
+        """
+        if len(self._error_text) != 0:
+            return False
+        else:
+            return True         

src/logic/start_factory.py

@@ -1,16 +1,52 @@
 from src.models.nomenclature_group_model import nomenclature_group_model
 from src.models.measurement_unit_model import measurement_unit_model
 from src.models.nomenclature_model import nomenclature_model
-from src.settings import settings
+from src.errors.error_proxy import error_proxy
+from src.settings.settings import settings
+from src.storage.storage import storage
+from src.validation.validator import validator
 
 #
 # Класс для обработки начало работы приложения
 #
 class start_factory:
     __options: settings = None
+    __storage: storage = None
+    __vtor = validator()
     
-    def __init__(self, options: settings) -> None:
-        self.__options = options
+    def __init__(self, _options: settings,
+                 _storage: storage = None) -> None:
+        
+        self.__vtor.check_type(_options, settings)
+        self.__vtor.check_type(_storage, storage)
+        self.__options = _options
+        self.__storage = _storage
+
+    def __save(self, key:str, items: list):
+        """
+            Сохранить данные
+        Args:
+            key (str): ключ доступ
+            items (list): список
+        """
+       
+        self.__vtor.check_type(key, str)
+        
+        if self.__storage == None:
+            self.__storage = storage()
+            
+        self.__storage.data[ key ] = items
+        
+        
+                
+    @property            
+    def storage(self):
+        """
+             Ссылка на объект хранилище данных
+        Returns:
+            _type_: _description_
+        """
+        return self.__storage
     
     @staticmethod
     def create_nomenclature_list():
@@ -21,9 +57,9 @@ class start_factory:
         result = []
         
         
-        item1 = nomenclature_model("Мука", "Мука пшеничная",
-                                   measurement_unit_model.create_kg(),
-                                   nomenclature_group_model.create_group())
+        item1 = nomenclature_model("Мука", "Мушка пшеничная", measurement_unit_model("грамм"), nomenclature_group_model("name"))
+        item1.group = nomenclature_group_model.create_group()
+        item1.unit = measurement_unit_model.create_kg()
         
         result.append(item1)
         
@@ -37,12 +73,17 @@ class start_factory:
         Returns:
             _type_: _description_
         """
+        
+        result = []
         if self.__options.is_first_run == True:
             self.__options.is_first_run = False
-            return start_factory.create_nomenclature_list()
-        else:
-            items = []
-            return items
+            
+            # Формируем и зпоминаем номеклатуру
+            result = start_factory.create_nomenclature_list()
+            self.__save(storage.nomenclature_key(), result )
+
+        return result
+
         
         
     

src/models/recipe_model.py

@@ -0,0 +1,60 @@
+from src.models.abstract_reference import abstract_reference
+from src.models.nomenclature_model import nomenclature_model
+from src.models.measurement_unit_model import measurement_unit_model
+from src.errors.error_proxy import error_proxy
+
+#
+# Класс описание одной строки рецепта
+#
+class receipe_model(abstract_reference):
+    __nomenclature: nomenclature_model = None
+    __size: int = 0
+    __unit: measurement_unit_model = None
+    
+    def __init__(self, _nomenclature: nomenclature_model, _size: int, _unit: measurement_unit_model):
+        error_proxy.validate(_nomenclature, abstract_reference)
+        error_proxy.validate(_unit, abstract_reference)
+         
+        self.__nomenclature = _nomenclature
+        self.__size = _size
+        self.__unit = _unit
+        
+        super().__init__( f"{_nomenclature.name} , {_unit.name} ")
+    
+    @property
+    def nomenclature(self):
+        """
+            Номенклатура
+        Returns:
+            _type_: _description_
+        """
+        return self.__nomenclature
+    
+    
+    @property
+    def size(self):
+        """
+            Размер
+
+        Returns:
+            _type_: _description_
+        """
+        return self.__size
+    
+    
+    @size.setter
+    def size(self, value: int):
+        self.__size = value
+    
+    
+    @property    
+    def unit(self):
+        """
+           Единица измерения
+
+        Returns:
+            _type_: _description_
+        """
+        return self.__unit    
+        
+    

src/storage/storage.py

@@ -1,15 +1,53 @@
-
-
 #
 # Класс хранилище данных
 #
 class storage:
     __data = {}
     
+    
     def __new__(cls):
         if not hasattr(cls, 'instance'):
             cls.instance = super(storage, cls).__new__(cls)
         return cls.instance  
-      
     
+    @property
+    def data(self) -> dict:
+        """
+         Данные по моделям
+
+        Returns:
+            _type_: _description_
+        """
+        return self.__data
+
+ 
+    @staticmethod
+    def nomenclature_key():
+        """
+            Ключ для хранения номенклатуры
+        Returns:
+            _type_: _description_
+        """
+        return "nomenclature"
+
+  
+    @staticmethod
+    def group_key():
+        """
+            Списк номенклатурных групп
+        Returns:
+            _type_: _description_
+        """
+        return "group"
+      
+      
+
+    @staticmethod  
+    def unit_key():
+        """
+              Список единиц измерения
+        Returns:
+            _type_: _description_
+        """
+        return "unit"
     

tests/test_factory.py

@@ -4,6 +4,8 @@ from src.settings.settings_manager import settings_manager
 
 import unittest
 
+from src.storage.storage import storage
+
 #
 # Набор автотестов для проверки работы фабричного метода
 # #
@@ -41,7 +43,8 @@ class factory_test(unittest.TestCase):
     def test_check_start_factor(self):
         # Подготовка
         manager = settings_manager()
-        factory = start_factory( manager.settings )
+        strg = storage()
+        factory = start_factory( manager.settings,  strg)
         
         
         # Действие