コード例 #1
0
ファイル: RulesUnitTest.cs プロジェクト: Srounsroun/myfood
        public void TestMethodTempMaxiCarp()
        {
            var currentMeasures = new GroupedMeasure();

            currentMeasures.waterTempvalue     = 32;
            currentMeasures.hydroponicTypeName = "Aquaponics - Carp";

            Assert.IsFalse(AquaponicsRulesManager.ValidateRules(currentMeasures, productionUnitId, productionUnitOwnerMail));
        }
コード例 #2
0
ファイル: RulesUnitTest.cs プロジェクト: Srounsroun/myfood
        public void TestMethodHumidityTempUnder30()
        {
            var currentMeasures = new GroupedMeasure();

            currentMeasures.airTempvalue       = 23;
            currentMeasures.humidityvalue      = 99;
            currentMeasures.hydroponicTypeName = "Not applicable";

            Assert.IsFalse(AquaponicsRulesManager.ValidateRules(currentMeasures, productionUnitId, productionUnitOwnerMail));
        }
コード例 #3
0
        private static void PerformValidationRules()
        {
            var db    = new ApplicationDbContext();
            var dbLog = new ApplicationDbContext();

            var upRunningStatus = db.ProductionUnitStatus.Where(s => s.Id == 3).FirstOrDefault();
            var offlineStatus   = db.ProductionUnitStatus.Where(s => s.Id == 6).FirstOrDefault();

            var productionUnits = db.ProductionUnits.Where(p => p.productionUnitStatus.Id == upRunningStatus.Id || p.productionUnitStatus.Id == offlineStatus.Id)
                                  .Include(p => p.productionUnitStatus)
                                  .Include(p => p.productionUnitType)
                                  .Include(p => p.owner.user)
                                  .Include(p => p.owner.language)
                                  .Include(p => p.hydroponicType)
                                  .Include(p => p.productionUnitStatus)
                                  .Include(p => p.productionUnitType).ToList();

            dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Processing starts @{0} for {1} Production Units", DateTime.Now, productionUnits.Count), Log.LogType.Information));
            dbLog.SaveChanges();

            productionUnits.ForEach(p =>
            {
                var currentMeasures = AquaponicsRulesManager.MeasuresProcessor(p.Id);

                try
                {
                    var reco = AquaponicsRulesManager.ValidateRules(currentMeasures, p.Id);

                    MailManager.PioneerUnitWeeklyMessage(p, reco);
                }
                catch (Exception ex)
                {
                    dbLog.Logs.Add(Log.CreateErrorLog(String.Format("Error with Rule Manager Evaluator"), ex));
                    dbLog.SaveChanges();
                }
            });

            dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Processing ended @{0} for {1} Production Units", DateTime.Now, productionUnits.Count), Log.LogType.Information));
            dbLog.SaveChanges();
        }
コード例 #4
0
        private static void PerformValidationRules()
        {
            var db    = new ApplicationDbContext();
            var dbLog = new ApplicationDbContext();

            var upRunningStatus = db.ProductionUnitStatus.Where(p => p.Id == 3).FirstOrDefault();

            var upRunningProductionUnits = db.ProductionUnits.Include(p => p.productionUnitStatus)
                                           .Where(p => p.productionUnitStatus.Id == upRunningStatus.Id).ToList();

            dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Processing starts @{0} for {1} Production Units", DateTime.Now, upRunningProductionUnits.Count), Log.LogType.Information));
            dbLog.SaveChanges();

            upRunningProductionUnits.ForEach(p =>
            {
                dbLog.Logs.Add(Log.CreateLog(String.Format("Measures Processing for {0}", p.info), Log.LogType.Information));
                dbLog.SaveChanges();

                var currentMeasures = AquaponicsRulesManager.MeasuresProcessor(p.Id);

                dbLog.Logs.Add(Log.CreateLog(String.Format("Measures Validating for {0}", p.info), Log.LogType.Information));
                dbLog.SaveChanges();

                try
                {
                    AquaponicsRulesManager.ValidateRules(currentMeasures, p.Id);
                }
                catch (Exception ex)
                {
                    dbLog.Logs.Add(Log.CreateErrorLog(String.Format("Error with Rule Manager Evaluator"), ex));
                    dbLog.SaveChanges();
                }

                dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Validation ended for {0}", p.info), Log.LogType.Information));
                dbLog.SaveChanges();
            });
        }
コード例 #5
0
        public ActionResult SendFeelingRequest()
        {
            var db    = new ApplicationDbContext();
            var dbLog = new ApplicationDbContext();

            //var db = new ApplicationDbContext();

            //var pr = db.ProductionUnits.Include(p => p.owner.user)
            //                                                  .Include(p => p.owner.language)
            //                                                  .Include(p => p.hydroponicType)
            //                                                  .Include(p => p.productionUnitStatus)
            //                                                  .Include(p => p.productionUnitType)
            //                                                  .Where(p => p.reference == "C087EF" || p.reference == "74711").FirstOrDefault();

            //var currentMeasures = AquaponicsRulesManager.MeasuresProcessor(pr.Id);

            //try
            //{
            //    var reco = AquaponicsRulesManager.ValidateRules(currentMeasures, pr.Id);
            //    MailManager.PioneerUnitWeeklyMessage(pr, reco);
            //}
            //catch (Exception ex)
            //{
            //    dbLog.Logs.Add(Log.CreateErrorLog(String.Format("Error with Rule Manager Evaluator"), ex));
            //    dbLog.SaveChanges();
            //}

            var upRunningStatus = db.ProductionUnitStatus.Where(s => s.Id == 3).FirstOrDefault();
            var offlineStatus   = db.ProductionUnitStatus.Where(s => s.Id == 6).FirstOrDefault();

            var productionUnits = db.ProductionUnits.Where(p => p.productionUnitStatus.Id == upRunningStatus.Id || p.productionUnitStatus.Id == offlineStatus.Id)
                                  .Include(p => p.productionUnitStatus)
                                  .Include(p => p.productionUnitType)
                                  .Include(p => p.owner.user)
                                  .Include(p => p.owner.language)
                                  .Include(p => p.hydroponicType)
                                  .Include(p => p.productionUnitStatus)
                                  .Include(p => p.productionUnitType).ToList();

            dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Processing starts @{0} for {1} Production Units", DateTime.Now, productionUnits.Count), Log.LogType.Information));
            dbLog.SaveChanges();

            productionUnits.ForEach(p =>
            {
                var currentMeasures = AquaponicsRulesManager.MeasuresProcessor(p.Id);

                try
                {
                    var reco = AquaponicsRulesManager.ValidateRules(currentMeasures, p.Id);
                    MailManager.PioneerUnitWeeklyMessage(p, reco);
                }
                catch (Exception ex)
                {
                    dbLog.Logs.Add(Log.CreateErrorLog(String.Format("Error with Rule Manager Evaluator"), ex));
                    dbLog.SaveChanges();
                }
            });

            dbLog.Logs.Add(Log.CreateLog(String.Format("Rules Processing ended @{0} for {1} Production Units", DateTime.Now, productionUnits.Count), Log.LogType.Information));
            dbLog.SaveChanges();

            //var upRunningStatus = db.ProductionUnitStatus.Where(s => s.Id == 3).FirstOrDefault();
            //var upRunningProductionUnits = db.ProductionUnits.Include(p => p.owner.language).Where(p => p.productionUnitStatus.Id == upRunningStatus.Id).ToList();

            //upRunningProductionUnits.ForEach(p =>
            //{
            //    if (p.owner.notificationPushKey != null)
            //    {
            //        NotificationPushManager.PioneerUnitOwnerFeelingMessage(p);
            //    }
            //});

            return(new HttpStatusCodeResult(HttpStatusCode.OK));
        }
コード例 #6
0
        // POST api/<controller>
        //[Authorize]
        public void Post([FromBody] JObject data)
        {
            var content = data["content"].ToObject <string>();
            var device  = data["device"].ToObject <string>();

            var db    = new ApplicationDbContext();
            var dbLog = new ApplicationDbContext();

            var date = DateTime.Now;

            try
            {
                var measureType = db.MessageTypes.Where(m => m.Id == 1).FirstOrDefault();

                db.Messages.Add(new Message()
                {
                    content = content, device = device, date = date, messageType = measureType
                });
                db.SaveChanges();
            }
            catch (Exception ex)
            {
                dbLog.Logs.Add(Log.CreateErrorLog("Error on Message from Sigfox", ex));
                dbLog.SaveChanges();
            }

            try
            {
                var currentProductionUnit = db.ProductionUnits.Include("owner.user").Include("hydroponicType").Where(p => p.reference == device).FirstOrDefault();

                if (currentProductionUnit == null)
                {
                    db.Logs.Add(Log.CreateLog(String.Format("Production Unit not found - {0}", device), Log.LogType.Warning));
                    db.SaveChanges();
                }

                var productionUnitOwnerMail = currentProductionUnit.owner.user.Email;

                var currentMeasures = new GroupedMeasure();
                currentMeasures.hydroponicTypeName = currentProductionUnit.hydroponicType.name;

                var phSensor = db.SensorTypes.Where(s => s.Id == 1).FirstOrDefault();
                var waterTemperatureSensor = db.SensorTypes.Where(s => s.Id == 2).FirstOrDefault();
                var dissolvedOxySensor     = db.SensorTypes.Where(s => s.Id == 3).FirstOrDefault();
                var ORPSensor            = db.SensorTypes.Where(s => s.Id == 4).FirstOrDefault();
                var airTemperatureSensor = db.SensorTypes.Where(s => s.Id == 5).FirstOrDefault();
                var airHumidity          = db.SensorTypes.Where(s => s.Id == 6).FirstOrDefault();

                var phContent           = content.Substring(0, 4).Insert(3, ".");
                var waterTempContent    = content.Substring(4, 4).Insert(3, ".");
                var dissolvedOxyContent = content.Substring(8, 4).Insert(3, ".");
                var orpContent          = content.Substring(12, 4).Insert(3, ".");
                var airTempContent      = content.Substring(16, 4).Insert(3, ".");
                var airHumidityContent  = content.Substring(20, 4).Insert(3, ".");

                if (!phContent.Contains("a"))
                {
                    decimal pHvalue = 0;
                    if (decimal.TryParse(phContent, out pHvalue))
                    {
                        currentMeasures.pHvalue = pHvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = phSensor, value = pHvalue
                        });
                        db.SaveChanges();
                    }
                }

                if (!waterTempContent.Contains("a"))
                {
                    decimal waterTempvalue = 0;
                    if (decimal.TryParse(waterTempContent, out waterTempvalue))
                    {
                        currentMeasures.waterTempvalue = waterTempvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = waterTemperatureSensor, value = waterTempvalue
                        });
                        db.SaveChanges();
                    }
                }

                if (!dissolvedOxyContent.Contains("a"))
                {
                    decimal DOvalue = 0;
                    if (decimal.TryParse(dissolvedOxyContent, out DOvalue))
                    {
                        currentMeasures.DOvalue = DOvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = dissolvedOxySensor, value = DOvalue
                        });
                        db.SaveChanges();
                    }
                }

                if (!orpContent.Contains("a"))
                {
                    decimal ORPvalue = 0;
                    if (decimal.TryParse(orpContent, out ORPvalue))
                    {
                        currentMeasures.ORPvalue = ORPvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = ORPSensor, value = ORPvalue
                        });
                        db.SaveChanges();
                    }
                }

                if (!airTempContent.Contains("a"))
                {
                    decimal airTempvalue = 0;
                    if (decimal.TryParse(airTempContent, out airTempvalue))
                    {
                        currentMeasures.airTempvalue = airTempvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = airTemperatureSensor, value = airTempvalue
                        });
                        db.SaveChanges();
                    }
                }

                if (!airHumidityContent.Contains("a"))
                {
                    decimal humidityvalue = 0;
                    if (decimal.TryParse(airHumidityContent, out humidityvalue))
                    {
                        currentMeasures.humidityvalue = humidityvalue;

                        db.Measures.Add(new Measure()
                        {
                            captureDate = date, productionUnit = currentProductionUnit, sensor = airHumidity, value = humidityvalue
                        });
                        db.SaveChanges();
                    }
                }

                DateTime lastDay = date.AddDays(-1);

                var currentLastDayPHValue = db.Measures.Where(m => m.captureDate > lastDay &&
                                                              m.productionUnit.Id == currentProductionUnit.Id &&
                                                              m.sensor.Id == phSensor.Id).OrderBy(m => m.Id).FirstOrDefault();

                if (currentLastDayPHValue == null)
                {
                    currentMeasures.lastDayPHvariation = 0;
                }
                else
                {
                    currentMeasures.lastDayPHvariation = Math.Abs(currentLastDayPHValue.value - currentMeasures.pHvalue);
                }

                AquaponicsRulesManager.ValidateRules(currentMeasures, currentProductionUnit.Id, productionUnitOwnerMail);
            }
            catch (Exception ex)
            {
                dbLog.Logs.Add(Log.CreateErrorLog("Error on Convert Message into Measure", ex));
                dbLog.SaveChanges();
            }
        }