Example #1
0
        public SensorGroupViewModel(SensorGroup sensorGroup)
        {
            this.Id   = sensorGroup.Id;
            this.Name = sensorGroup.Name;

            if (!String.IsNullOrEmpty(sensorGroup.TimeStamp))
            {
                if (!String.IsNullOrEmpty(sensorGroup.Name))
                {
                    this.Name += " " + DateTimeUtil.HowLongAgo(sensorGroup.TimeStamp);
                }
            }

            List <SensorViewModel>      sensors = new List <SensorViewModel>();
            List <SensorValueViewModel> values  = new List <SensorValueViewModel>();

            if (sensorGroup.Items != null)
            {
                foreach (var sensor in sensorGroup.Items)
                {
                    if (sensor.Value?.Values != null)
                    {
                        var sensorViewModel = new SensorViewModel(sensor.Value);
                        if (sensorViewModel.Values != null && sensorViewModel.Values.Any())
                        {
                            values.AddRange(sensorViewModel.Values);
                        }
                    }
                }
            }

            this.Sensors      = sensors;
            this.SensorValues = values;
        }
        public async Task <IActionResult> Update([FromRoute] int sensorId, [FromBody] SensorViewModel sensor)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var dbSensor = new Sensor()
            {
                Id       = sensorId,
                DeviceId = sensor.DeviceId,
                Name     = sensor.Name
            };

            _context.Sensors.Update(dbSensor);

            var sensorProperties = sensor.Properties.Select(sp => new SensorProperty()
            {
                SensorId = dbSensor.Id,
                Name     = sp.Name,
                Value    = sp.Value
            });

            _context.SensorProperties.RemoveRange(_context.SensorProperties.Where(sp => sp.SensorId.Equals(sensorId)));
            _context.SensorProperties.AddRange(sensorProperties);

            await _context.SaveChangesAsync();

            var sensorModel = dbSensor.ToViewModel();

            sensorModel.Properties = sensorProperties.Select(sp => sp.ToViewModel());

            return(Ok(sensorModel));
        }
Example #3
0
        public async Task <IActionResult> Edit(int id, [Bind("SensorId,Identificator,Units,Name,Description,Groups")] SensorViewModel sensor)
        {
            var sensorData = await _context.Sensors.Include(x => x.Groups).FirstAsync(x => x.SensorId == id);

            if (sensorData == null)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _mapper.Map(sensor, sensorData);
                    _context.Update(sensorData);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SensorExists(sensor.SensorId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sensor));
        }
Example #4
0
        public ActionResult ShowDetails(int id)
        {
            var sensor = this.sensorService.GetUserSensorById(id);

            if (sensor == null)
            {
                return(this.View("NotAuthenticated"));
            }
            var sensorViewModel = new SensorViewModel()
            {
                Id              = sensor.Id,
                CurrentValue    = sensor.CurrentValue,
                Name            = sensor.Name,
                Description     = sensor.Description,
                Url             = sensor.URL,
                IsValueType     = !sensor.IsBoolType,
                PollingInterval = sensor.PollingInterval,
                MeasurementType = sensor.MeasurementType,
                IsPublic        = sensor.IsPublic,
                IsShared        = sensor.IsShared,
                IsReadOnly      = true
            };

            return(this.View("ShowDetails", sensorViewModel));
        }
Example #5
0
        public SensorController(IHttpContextAccessor httpContextAccessor, IMemoryCache memoryCache)
        {
            _httpContextAccessor = httpContextAccessor;
            _cache = memoryCache;

            SensorViewModel model = new SensorViewModel(_cache);
        }
Example #6
0
        public SensorViewModel Get(int sensorId)
        {
            SensorViewModel sensor = null;
            var             now    = DateTime.Now;

            using (var dbContext = new Entities())
            {
                var dbSensor           = dbContext.Sensors.FirstOrDefault(s => s.Id == sensorId);
                var sensorMeasurements = dbSensor.SensorMeasurements.Where(sm => sm.MeasureDate > now.AddDays(-5));
                if (dbSensor != null)
                {
                    sensor = new SensorViewModel()
                    {
                        Id           = dbSensor.Id,
                        SensorName   = dbSensor.SensorName,
                        Description  = dbSensor.Description,
                        MinValue     = sensorMeasurements.Any() ? dbSensor.SensorMeasurements.Min(sm => sm.Value) : 0,
                        MaxValue     = sensorMeasurements.Any() ? dbSensor.SensorMeasurements.Max(sm => sm.Value) : 0,
                        Measurements = sensorMeasurements.Select(sm => new SensorMeasurementsViewModel()
                        {
                            DeviceId    = sm.DeviceId,
                            Id          = sm.Id,
                            Lat         = sm.Lat,
                            Long        = sm.Long,
                            MeasureDate = sm.MeasureDate,
                            SensorId    = sm.SensorId,
                            Value       = sm.Value
                        })
                    };
                }
            }
            return(sensor);
        }
        public IActionResult Modify(SensorViewModel sensorViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(this.View());
            }

            var sensor = sensorService.GetSensorById(sensorViewModel.ID);

            sensor.Name          = sensorViewModel.Name;
            sensor.Description   = sensorViewModel.Description;
            sensor.PoolInterval  = sensorViewModel.PollingIntervalInSeconds;
            sensor.Latitude      = sensorViewModel.Latitude;
            sensor.Longitude     = sensorViewModel.Longitude;
            sensor.ValueRangeMin = sensorViewModel.ValueRangeMin;
            sensor.ValueRangeMax = sensorViewModel.ValueRangeMax;
            sensor.IsPublic      = sensorViewModel.IsPublic;

            sensorService.UpdateSensor(editedSensor: sensor);

            //string actionName = nameof(this.Details);
            //string controllerName = nameof(SensorController).Replace("Controller", "");
            //int routeValue = sensor.ID;

            //return RedirectToAction(actionName, controllerName, routeValue);

            return(RedirectToAction("Index", "Home"));
        }
        public async Task Create_WithValidSensor_ReturnsCreatedSensor()
        {
            // Arrange
            var testSensor = new SensorViewModel()
            {
                DeviceId   = 1,
                Name       = "TestSensor",
                Properties = new List <SensorPropertyViewModel>()
                {
                    new SensorPropertyViewModel()
                    {
                        Name  = "Property",
                        Value = "JSDH6H"
                    }
                }
            };
            var dbContext  = Setup.GetDbContext();
            var controller = new SensorController(dbContext);

            // Act
            var result = await controller.Create(testSensor);

            // Assert
            var okObjectResult = Assert.IsType <OkObjectResult>(result);
            var sensor         = Assert.IsAssignableFrom <SensorViewModel>(okObjectResult.Value);

            Assert.Equal(1, sensor.Id);
            Assert.Equal(testSensor.Name, sensor.Name);
            Assert.All(testSensor.Properties, testSensorProperty =>
            {
                var sensorProperty = sensor.Properties.SingleOrDefault(sp => sp.Name.Equals(testSensorProperty.Name));
                Assert.NotNull(sensorProperty);
                Assert.Equal(testSensorProperty.Value, sensorProperty.Value);
            });
        }
Example #9
0
        public ActionResult Edit(Guid id)
        {
            CacheHelper.SetPreviousPage(_cache, Request.Headers["Referer"].ToString());
            SensorViewModel model = new SensorViewModel(_cache, id);

            return(View(model));
        }
Example #10
0
        public ActionResult ShareSensor(int id)
        {
            var sensor = this.sensorService.GetUserSensorById(id);

            if (this.User.Identity.GetUserId() != sensor.OwnerId)
            {
                return(View("NotAuthenticated"));
            }

            var sensorViewModel = new SensorViewModel()
            {
                Id              = sensor.Id,
                CurrentValue    = sensor.CurrentValue,
                Name            = sensor.Name,
                Description     = sensor.Description,
                Url             = sensor.URL,
                PollingInterval = sensor.PollingInterval,
                IsValueType     = !sensor.IsBoolType,
                MeasurementType = sensor.MeasurementType,
                IsPublic        = sensor.IsPublic,
                IsShared        = sensor.IsShared
            };

            return(View("ShareSensor", sensorViewModel));
        }
Example #11
0
        private async void SensorConfigMenu_Delete_ClickAsync(object sender, RoutedEventArgs e)
        {
            MenuFlyoutItem configMenuItem = (MenuFlyoutItem)sender;
            Tuple <SensorViewModel, Rectangle, Viewbox, CompositeTransform> sensorTuple =
                (Tuple <SensorViewModel, Rectangle, Viewbox, CompositeTransform>)configMenuItem.Tag;
            SensorViewModel sensorViewModel = sensorTuple.Item1;
            string          message         = "Are you sure that you want to perminantly remove sensor " + sensorViewModel.Name + "?";
            var             dialog          = new Windows.UI.Popups.MessageDialog(message, "Remove Sensor");

            dialog.Commands.Add(new Windows.UI.Popups.UICommand("Yes")
            {
                Id = 0
            });
            dialog.Commands.Add(new Windows.UI.Popups.UICommand("Cancel")
            {
                Id = 1
            });
            var result = await dialog.ShowAsync();

            if (result.Label == "Yes")
            {
                // Remove Sensor
                sensorCanvas.Children.Remove(sensorTuple.Item2);
                sensorCanvas.Children.Remove(sensorTuple.Item3);
                _viewModel.RemoveSensor(sensorViewModel);
                canvasSensorList.Remove(sensorTuple);
                sensorCanvas.InvalidateArrange();
                sensorCanvas.UpdateLayout();
            }
        }
Example #12
0
        private void Sensor_RightTapped(object sender, RightTappedRoutedEventArgs e)
        {
            Rectangle       sensorRect      = null;
            SensorViewModel sensorViewModel = null;
            Tuple <SensorViewModel, Rectangle, Viewbox, CompositeTransform> tuple = FindSensorIndexInTupleList(sender);

            if (tuple == null)
            {
                return;
            }
            sensorViewModel = tuple.Item1;
            sensorRect      = tuple.Item2;
            _viewModel.SensorCategorySelected = SensorType.GetSensorCategory(sensorViewModel.SensorTypes[0].Category);
            _viewModel.SensorSelected         = sensorViewModel;
            MenuFlyout     sensorConfigMenu        = new MenuFlyout();
            MenuFlyoutItem sensorConfigMenu_Config = new MenuFlyoutItem
            {
                Text = "Edit",
                Tag  = tuple
            };

            sensorConfigMenu_Config.Click += BtnEditSensor_ClickAsync;
            MenuFlyoutItem sensorConfigMenu_Delete = new MenuFlyoutItem
            {
                Text = "Delete",
                Tag  = tuple
            };

            sensorConfigMenu_Delete.Click += SensorConfigMenu_Delete_ClickAsync;
            sensorConfigMenu.Items.Add(sensorConfigMenu_Config);
            sensorConfigMenu.Items.Add(sensorConfigMenu_Delete);
            sensorConfigMenu.ShowAt(sensorRect, new Point(sensorRect.ActualWidth, sensorRect.ActualHeight));
        }
Example #13
0
        public SensorViewModel GetSensorViewModel()
        {
            var sensorViewModel = new SensorViewModel();
            var departements    = departementRepository.GetAllDepartments();

            sensorViewModel.Departements = departements;
            return(sensorViewModel);
        }
        public async Task Update_WithValidSensor_ReturnsUpdatedSensor()
        {
            // Arrange
            var testSensor = new SensorViewModel()
            {
                DeviceId   = 1,
                Name       = "TestSensor",
                Properties = new List <SensorPropertyViewModel>()
                {
                    new SensorPropertyViewModel()
                    {
                        Name  = "Property",
                        Value = "JSDH6H"
                    }
                }
            };
            var dbContext   = Setup.GetDbContext();
            var sensorEntry = dbContext.Sensors.Add(new Sensor()
            {
                Id       = 10,
                DeviceId = 1,
                Name     = "SensorName"
            });
            var sensorProperty1 = dbContext.SensorProperties.Add(new SensorProperty()
            {
                SensorId = 10,
                Name     = "Property",
                Value    = "KDU8J"
            });
            var sensorProperty2 = dbContext.SensorProperties.Add(new SensorProperty()
            {
                SensorId = 10,
                Name     = "Key",
                Value    = "12DE83"
            });
            await dbContext.SaveChangesAsync();

            sensorEntry.State     = EntityState.Detached;
            sensorProperty1.State = EntityState.Detached;
            sensorProperty2.State = EntityState.Detached;
            var controller = new SensorController(dbContext);

            // Act
            var result = await controller.Update(10, testSensor);

            // Assert
            var okObjectResult = Assert.IsType <OkObjectResult>(result);
            var sensor         = Assert.IsAssignableFrom <SensorViewModel>(okObjectResult.Value);

            Assert.Equal(10, sensor.Id);
            Assert.Equal(testSensor.Name, sensor.Name);
            Assert.All(testSensor.Properties, testSensorProperty =>
            {
                var sensorProperty = sensor.Properties.SingleOrDefault(sp => sp.Name.Equals(testSensorProperty.Name));
                Assert.NotNull(sensorProperty);
                Assert.Equal(testSensorProperty.Value, sensorProperty.Value);
            });
        }
Example #15
0
 public UserSensorWithData(SensorViewModel viewModel)
 {
     this.DeviceId   = viewModel.DeviceId;
     this.Id         = viewModel.Id;
     this.Location   = viewModel.Location;
     this.Name       = viewModel.Name;
     this.SensorType = viewModel.SensorType;
     SensorTypeId    = viewModel.SensorTypeId;
 }
Example #16
0
        // GET: /<controller>/



        public IActionResult Index()
        {
            var viewmodel = new SensorViewModel()
            {
                Sensors = _sensorRepository.GetAllSensors().ToList()
            };

            return(View(viewmodel));
        }
Example #17
0
        public async Task <IActionResult> Put(SensorViewModel sensorModel)
        {
            var sensor = _mapper.Map <SensorViewModel, Sensor>(sensorModel);

            _context.Entry(sensor).State = EntityState.Modified;
            await _context.SaveChangesAsync();

            return(NoContent());
        }
Example #18
0
        public async Task <IActionResult> Post(SensorViewModel sensorModel)
        {
            var sensor = _mapper.Map <SensorViewModel, Sensor>(sensorModel);

            _context.Add(sensor);
            await _context.SaveChangesAsync();

            return(Ok(sensor.ID));
        }
Example #19
0
        public ActionResult AddSensor()
        {
            var userId = GetUserId();
            var model  = new SensorViewModel
            {
                AveableDevices = deviceManager.GetDevices(userId)
            };

            return(View(model));
        }
        public async Task <IActionResult> EditSensor(SensorViewModel viewModel)
        {
            var sensorMinMaxValuesList = new List <double>(await this.userSensorService.GetSensorsTypeMinMaxValues(viewModel.Tag));

            viewModel.SensorTypeMinVal = sensorMinMaxValuesList[0];

            viewModel.SensorTypeMaxVal = sensorMinMaxValuesList[1];

            return(View(viewModel));
        }
Example #21
0
        public ActionResult CreateSensor(SensorViewModel model)
        {
            if (ModelState.IsValid)
            {
                var sensor = new DataflowICB.Database.Models.Sensor()
                {
                    OwnerId         = this.User.Identity.GetUserId(),
                    Description     = model.Description,
                    IsPublic        = model.IsPublic,
                    Name            = model.Name,
                    URL             = model.Url,
                    PollingInterval = model.PollingInterval,
                    LastUpdate      = DateTime.Now
                };

                if (model.IsValueType)
                {
                    var valueType = new ValueTypeSensor()
                    {
                        MeasurementType = model.MeasurementType,
                        //IsInAcceptableRange = model.ValueTypeSensor.IsInAcceptableRange,
                        Maxvalue = model.MaxValue,
                        MinValue = model.MinValue
                    };
                    sensor.IsBoolType      = false;
                    sensor.ValueTypeSensor = valueType;
                }
                else
                {
                    var boolType = new BoolTypeSensor()
                    {
                        MeasurementType = model.MeasurementType
                    };

                    sensor.IsBoolType     = true;
                    sensor.BoolTypeSensor = boolType;
                }

                this.sensorService.AddSensor(sensor);

                return(this.Json("Successfully Registered !"));
            }
            else
            {
                if (model.IsValueType)
                {
                    return(this.View("RegisterValueSensor", model));
                }
                else
                {
                    return(this.View("RegisterBoolSensor", model));
                }
            }
        }
Example #22
0
        public void Put(int id, [FromBody] SensorViewModel model)
        {
            var sensor = this._db.sensores.Single(s => s.Id == id);

            sensor.acao  = model.acao;
            sensor.tipo  = model.tipo;
            sensor.valor = model.valor;

            this._db.sensores.Update(sensor);
            this._db.SaveChanges();
        }
Example #23
0
        public ActionResult CreateSensor(SensorViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                model.OwnerId = this.userManager.FindByNameAsync(this.User.Identity.Name).Result.Id;
                this.service.CreateSensor(model);
                return(this.RedirectToAction("MySensors"));
            }
            ;

            return(this.View());
        }
        public async Task <IActionResult> RegisterSensor(SensorViewModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return(View(model));
            }

            await this.userSensorService.AddSensorAsync(model.UserId, model.Id, model.Name, model.Description, model.MinValue, model.MaxValue,
                                                        model.PollingInterval, model.Latitude, model.Longtitude, model.IsPublic, model.Alarm, model.ImageURL);

            return(RedirectToAction("Index", "Home", new { area = "" }));
        }
Example #25
0
        public IActionResult Post([FromBody] SensorViewModel model)
        {
            if (model == null)
            {
                return(StatusCode(500, new InternalServerError()));
            }
            if (!ModelState.IsValid)
            {
                return(StatusCode(500, new InternalServerError("Incorrect data!")));
            }

            var sensor = _context.Sensors
                         .Include(p => p.SensorType)
                         .Where(p => p.Id == model.Id)
                         .FirstOrDefault();

            if (sensor == null)
            {
                return(NotFound(new NotFoundError()));
            }

            var user = User.GetUser(_context);

            var userHasController = _context.UserHasControllers
                                    .Where(p => p.ControllerId == sensor.ControllerId)
                                    .Where(p => p.UserId == user.Id)
                                    .Where(p => p.IsAdmin);

            if (userHasController == null)
            {
                return(Unauthorized(new UnauthorizedError()));
            }

            var sensors = _context.Sensors
                          .Where(p => p.ControllerId == sensor.ControllerId)
                          .Where(p => p.Pin == sensor.Pin)
                          .Where(p => p.Id != sensor.Id);

            //Перевіряємо чи до цього піну підключені інші сенсори
            if (sensors.Any())
            {
                return(StatusCode(500, new InternalServerError("Pin is already taken!")));
            }

            //змінюємо модель
            sensor.Name         = model.Name;
            sensor.Pin          = model.Pin;
            sensor.Status       = model.Status;
            sensor.SensorTypeId = model.SensorTypeId;

            _context.SaveChanges();
            return(Json(sensor.Adapt <SensorViewModel>()));
        }
Example #26
0
        public ActionResult EditSensor(SensorViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                var userId = this.userManager.GetUserId(this.User);
                this.service.EditSensor(model, userId);
                return(this.RedirectToAction("EditSensors"));
            }
            ;

            return(this.View());
        }
Example #27
0
        public void TestSensorViewModel()
        {
            var viewmodel = new SensorViewModel(sensorService);

            ObservableCollection <Sensor> expectedData = new ObservableCollection <Sensor>(sensorService.All());
            var sensor = sensorService.Find(1);

            viewmodel.SelectedSensor = sensor;

            Assert.AreEqual(expectedData.Count, viewmodel.Sensors.Count);
            Assert.IsNotNull(viewmodel.SelectedSensor);
            Assert.AreEqual(1, viewmodel.SelectedSensor.Sensor_id);
        }
Example #28
0
        public SensorViewModel GetrealTimeSensorsData(int id)
        {
            SensorViewModel sensor = new SensorViewModel();

            //Parent parent = Parents.Where(p =>
            //                p.Zone == zone
            //                && p.parentNumber == parentNumber).First();
            //for (int i = 0; i < 3; i++)
            //{
            //    sensor.Sensor[i] = parent.Sensor[i].GetLatestData();
            //}

            return(sensor);
        }
Example #29
0
        public Sensor Post([FromBody] SensorViewModel model)
        {
            var sensor = new Sensor();

            sensor.acao    = model.acao;
            sensor.tipo    = model.tipo;
            sensor.valor   = model.valor;
            sensor.veiculo = this._db.veiculos.Single(s => s.Id == model.veiculoId);

            this._db.sensores.Add(sensor);
            this._db.SaveChanges();

            return(sensor);
        }
Example #30
0
        public SensorDataPage(Device currentDevice)
        {
            logger.TAG = "SensorDataPage";

            logger.LogInfo(String.Format("{0} - {1}", currentDevice.Name, currentDevice.Address));
            sensorViewModel = new SensorViewModel(new DeviceViewModel(currentDevice.Name, currentDevice.Address));
            nativeSensorData.Init(sensorViewModel, currentDevice);
            this.BindingContext = sensorViewModel;

            logger.TraceInformation("----  The ending of the problem place. -----");
            logger.TraceInformation("--------------------------------------------");

            InitializeComponent();
        }
        private void GetSensorsWithPrices()
        {
            var phenomenas = Enum.GetValues(typeof(SensingPhenomena)).Cast<SensingPhenomena>();

            foreach (var phenomena in phenomenas)
            {
                var sensor = new SensorViewModel{Phenomena = phenomena};
                sensor.Price = GetPhenomenaDefaultPrice(phenomena);

                Sensors.Add(sensor);
            }
        }