Update app.py

app.py

@@ -691,101 +691,102 @@ class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         self.results = {}
-        self.target_profile = {}
-        self.actual_profile = {}
+        self.target_profile = {
+            'P': 0, 'K': 0, 'Mg': 0, 'Ca': 0, 'S': 0,
+            'N (NO3-)': 0, 'N (NH4+)': 0
+        }
+        self.actual_profile = {
+            'P': 0.0, 'K': 0.0, 'Mg': 0.0, 'Ca': 0.0, 'S': 0.0,
+            'N (NO3-)': 0.0, 'N (NH4+)': 0.0
+        }
         self.fertilizers = {}
         self.total_ec = 0.0
 
-    def set_target_profile(self, profile):
-        """Устанавливаем целевой профиль извне"""
-        self.target_profile = profile.copy()
-        self.actual_profile = {k: 0.0 for k in profile}
+    def set_target_profile(self, profile_data):
+        """Устанавливаем целевые значения"""
+        for key in profile_data:
+            if key in self.target_profile:
+                self.target_profile[key] = float(profile_data[key])
 
-    def set_fertilizers(self, fertilizers):
-        """Устанавливаем состав удобрений извне"""
-        self.fertilizers = fertilizers
+    def set_fertilizers(self, fertilizers_data):
+        """Принимаем удобрения в любом формате (рус/англ)"""
+        self.fertilizers = fertilizers_data
 
     def calculate(self):
-        """Основной расчёт"""
+        """Основная логика расчёта без изменений"""
         try:
-            # Расчёт по порядку внесения удобрений
-            self._apply_fertilizer("Сульфат магния", "Mg")
-            self._apply_fertilizer("Кальциевая селитра", "Ca")
-            self._apply_fertilizer("Монофосфат калия", "P")
-            self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)")
+            # Порядок внесения удобрений
+            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
+            self._apply("Кальциевая селитра", "Ca", self.target_profile['Ca'])
+            self._apply("Монофосфат калия", "P", self.target_profile['P'])
+            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
             
             # Довносим NO3 если нужно
             no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
             if no3_needed > 0.1:
-                self._apply_fertilizer("Калий азотнокислый", "N (NO3-)", no3_needed)
+                self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
             
             # Довносим калий если нужно
-            k_needed = self.target_profile['K'] - self.actual_profile['K']
-            if k_needed > 0.1:
-                self._apply_fertilizer("Калий азотнокислый", "K", k_needed)
-            
-            # Довносим серу если нужно
-            s_needed = self.target_profile['S'] - self.actual_profile['S']
-            if s_needed > 0.1:
-                self._apply_fertilizer("Калий сернокислый", "S", s_needed)
+            k_deficit = self.target_profile['K'] - self.actual_profile['K']
+            if k_deficit > 0.1:
+                self._apply("Калий азотнокислый", "K", k_deficit)
             
             return True
         except Exception as e:
-            print(f"Calculation error: {str(e)}")
+            print(f"Ошибка расчёта: {str(e)}")
             return False
 
-    def _apply_fertilizer(self, name, element, required_ppm=None):
+    def _apply(self, fert_name, element, required_ppm):
         """Универсальный метод внесения удобрений"""
-        if name not in self.fertilizers:
+        if fert_name not in self.fertilizers or required_ppm <= 0:
             return
 
-        if required_ppm is None:
-            required_ppm = self.target_profile[element] - self.actual_profile[element]
-        
-        if required_ppm <= 0:
-            return
-
-        content = self.fertilizers[name].get(element, 0)
-        if content == 0:
+        content = self.fertilizers[fert_name].get(element, 0)
+        if content <= 0:
             return
 
         grams = (required_ppm * self.volume) / (content * 1000)
         
-        # Записываем результаты
-        if name not in self.results:
-            self.results[name] = {'grams': 0.0, 'adds': {}}
+        # Сохраняем результаты
+        if fert_name not in self.results:
+            self.results[fert_name] = {
+                'grams': 0.0,
+                'adds': {}
+            }
         
-        self.results[name]['grams'] += grams
+        self.results[fert_name]['grams'] += grams
         
-        # Обновляем фактические концентрации
-        for nutrient, percent in self.fertilizers[name].items():
+        # Обновляем профиль
+        for nutrient, percent in self.fertilizers[fert_name].items():
             added_ppm = (grams * percent * 1000) / self.volume
             self.actual_profile[nutrient] = self.actual_profile.get(nutrient, 0) + added_ppm
-            self.results[name]['adds'][nutrient] = self.results[name]['adds'].get(nutrient, 0) + added_ppm
+            self.results[fert_name]['adds'][nutrient] = self.results[fert_name]['adds'].get(nutrient, 0) + added_ppm
         
         # Расчёт EC
         self.total_ec += sum(
-            added_ppm * 0.0015  # Упрощённый коэффициент
-            for nutrient, added_ppm in self.results[name]['adds'].items()
+            added_ppm * {
+                'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015,
+                'Ca': 0.0016, 'S': 0.0014,
+                'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
+            }.get(nutrient, 0.0015)
+            for nutrient, added_ppm in self.results[fert_name]['adds'].items()
         )
 
     def get_results(self):
-        """Возвращаем результаты в стандартном формате"""
+        """Форматируем результаты"""
         return {
             'fertilizers': [
                 {
                     'name': name,
                     'grams': round(data['grams'], 3),
                     'adds': {k: round(v, 3) for k, v in data['adds'].items()}
-                } 
-                for name, data in self.results.items()
+                } for name, data in self.results.items()
             ],
             'profile': [
                 {
                     'element': k.replace(' (NO3-)', '-NO3').replace(' (NH4+)', '-NH4'),
                     'ppm': round(v, 3)
-                }
-                for k, v in self.actual_profile.items()
+                } for k, v in self.actual_profile.items()
             ],
             'ec': round(self.total_ec, 2),
             'deficits': {
@@ -799,30 +800,20 @@ def handle_calculation():
     try:
         data = request.json
         
+        # Проверяем обязательные поля
+        if 'fertilizerConstants' not in data or 'profileSettings' not in data:
+            return jsonify({'status': 'error', 'message': 'Missing required fields'}), 400
+        
         # Создаём калькулятор
         calculator = NutrientCalculator(volume_liters=data['profileSettings']['liters'])
         
-        # Настраиваем профиль
-        calculator.set_target_profile({
-            'P': float(data['profileSettings']['P']),
-            'K': float(data['profileSettings']['K']),
-            'Mg': float(data['profileSettings']['Mg']),
-            'Ca': float(data['profileSettings']['Ca']),
-            'S': float(data['profileSettings']['S']),
-            'N (NO3-)': float(data['profileSettings']['N (NO3-)']),
-            'N (NH4+)': float(data['profileSettings']['N (NH4+)'])
-        })
+        # Настраиваем профиль (принимаем как есть)
+        calculator.set_target_profile(data['profileSettings'])
         
-        # Настраиваем удобрения
-        calculator.set_fertilizers({
-            "Кальциевая селитра": {
-                "N (NO3-)": float(data['fertilizerConstants']['CaN2O6']['NO3']) / 100,
-                "Ca": float(data['fertilizerConstants']['CaN2O6']['Ca']) / 100
-            },
-            # ... остальные удобрения аналогично
-        })
+        # Настраиваем удобрения (принимаем как есть, без преобразований)
+        calculator.set_fertilizers(data['fertilizerConstants'])
         
-        # Выполняем расчёт
+        # Расчёт
         if calculator.calculate():
             return jsonify({
                 'status': 'success',
@@ -858,7 +849,6 @@ def handle_calculation():
 
 
 
-
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))