Esempio n. 1
0
        public WasteManagementEvent CreateExceptionModel()
        {
            var wasteManagementEventModel = new WasteManagementEvent
            {
                Address = new Address()
                {
                    Street1 = Street1,
                    Street2 = Street2,
                    City    = City,
                    State   = State,
                    ZipCode = ZipCode,
                    Country = Country,
                },

                ExceptionDetails = new ExceptionDetails()
                {
                    Type        = ExceptiuonType,
                    Description = ExceptionDescription,
                    Notes       = ExceptionNotes,
                    PictureUrls = new string[] { Url1, Url2 }
                },

                VideoUrls = new List <VideoUrl>
                {
                    new VideoUrl()
                    {
                        Altitude      = Altitude,
                        StartDateTime = VideoStartDateTime,
                        EndDateTime   = VideoEndDateTime,
                        Heading       = Heading,
                        Latitude      = VideoLatitude,
                        Longitude     = VideoLongitude,
                        Speed         = Speed,
                        MDTUrl        = "www.yahoo.com/video1",
                        Url           = "www.yahoo.com/video1",
                        Camera        = 1
                    }
                },

                Vin            = Vin,
                AccountId      = AccountId,
                EventId        = EventId,
                EventType      = EventType,
                TransactionId  = TransactionId,
                DateTime       = System.DateTime.Now,
                Longitude      = Longitude,
                Latitude       = Latitude,
                ContainerColor = ContainerColor,
                ContainerSize  = ContainerSize,
            };

            return(wasteManagementEventModel);
        }
Esempio n. 2
0
        public void TestPost_RecordSuccessfullyCreated()
        {
            var eventId = "some-event-id";
            WasteManagementEvent exceptionModel = _testData.CreateExceptionModel();

            exceptionModel.Vin = eventId;

            var result = _controller.Create(exceptionModel);

            _dbSetMock.Verify(mock => mock.Add(It.IsAny <WasteManagementEventEntity>()), Times.Once());
            _dbContextMock.Verify(mock => mock.SaveChanges(), Times.Once());
            Assert.AreEqual(typeof(StatusCodeResult), result.GetType());
        }
Esempio n. 3
0
        public ActionResult Create([FromBody] WasteManagementEvent data)
        {
            bool isRecordExists = _dbContext.WasteManagementEvents.Any(o => o.EventId == data.EventId);

            if (!isRecordExists)
            {
                WasteManagementEventEntity wasteManagementEvent = _transformer.TransformToExceptionEntity(data);
                _dbContext.WasteManagementEvents.Add(wasteManagementEvent);
                _dbContext.SaveChanges();
                return(new StatusCodeResult(201));
            }
            else
            {
                return(new ValidationFailedResult(new ValidationResultModel(string.Format("Record with EventId \"{0}\" already exists.", data.EventId))));
            }
        }
Esempio n. 4
0
        public void TestTransformToExceptionModel()
        {
            WasteManagementEventEntity wasteManagementEventEntity = _testData.CreateWasteManagementEvent();

            WasteManagementEvent result = _transformer.TransformToExceptionModel(wasteManagementEventEntity);

            Assert.AreEqual(wasteManagementEventEntity.Vin, result.Vin);
            Assert.AreEqual(wasteManagementEventEntity.AccountId, result.AccountId);
            Assert.AreEqual(wasteManagementEventEntity.EventId, result.EventId);
            Assert.AreEqual(wasteManagementEventEntity.EventType, result.EventType);
            Assert.AreEqual(wasteManagementEventEntity.TransactionId, result.TransactionId);
            Assert.AreEqual(wasteManagementEventEntity.DateTime, result.DateTime);
            Assert.AreEqual(wasteManagementEventEntity.Longitude, result.Longitude);
            Assert.AreEqual(wasteManagementEventEntity.Latitude, result.Latitude);

            Assert.AreEqual(wasteManagementEventEntity.Street1, result.Address.Street1);
            Assert.AreEqual(wasteManagementEventEntity.Street2, result.Address.Street2);
            Assert.AreEqual(wasteManagementEventEntity.City, result.Address.City);
            Assert.AreEqual(wasteManagementEventEntity.State, result.Address.State);
            Assert.AreEqual(wasteManagementEventEntity.ZipCode, result.Address.ZipCode);
            Assert.AreEqual(wasteManagementEventEntity.Country, result.Address.Country);

            Assert.AreEqual(wasteManagementEventEntity.ExceptionDetails.Type, result.ExceptionDetails.Type);
            Assert.AreEqual(wasteManagementEventEntity.ContainerColor, result.ContainerColor);
            Assert.AreEqual(wasteManagementEventEntity.ContainerSize, result.ContainerSize);
            Assert.AreEqual(wasteManagementEventEntity.ExceptionDetails.Description, result.ExceptionDetails.Description);
            Assert.AreEqual(wasteManagementEventEntity.ExceptionDetails.Notes, result.ExceptionDetails.Notes);

            List <string> urls = new List <string>(result.ExceptionDetails.PictureUrls);

            Assert.IsTrue(urls.Any(item => item == TestDataCreator.Url1));
            Assert.IsTrue(urls.Any(item => item == TestDataCreator.Url2));

            VideoUrl    videoUrl       = result.VideoUrls.First();
            VideoEntity videoUrlEntity = wasteManagementEventEntity.Videos.First();

            Assert.AreEqual(videoUrl.Heading, videoUrlEntity.Heading);
            Assert.AreEqual(videoUrl.Latitude, videoUrlEntity.Latitude);
            Assert.AreEqual(videoUrl.Longitude, videoUrlEntity.Longitude);
            Assert.AreEqual(videoUrl.MDTUrl, videoUrlEntity.MDTUrl);
            Assert.AreEqual(videoUrl.Url, videoUrlEntity.VideoURL);
            Assert.AreEqual(videoUrl.Speed, videoUrlEntity.Speed);
            Assert.AreEqual(videoUrl.EndDateTime, videoUrlEntity.EndDateTime);
            Assert.AreEqual(videoUrl.StartDateTime, videoUrlEntity.StartDateTime);
            Assert.AreEqual(videoUrl.Camera, videoUrlEntity.CameraChannel);
        }