public void CreateMeasures_WhenThereIsNoSequenceForTheMeasureCreatedDate_ApplicationExceptionThrown()
        {
            var standardId = Guid.NewGuid();

            var batchId = Guid.NewGuid();

            var geneticLineId = Guid.NewGuid();

            var batchCreatedDate = new DateTime(2015, 09, 09);

            var batch = new Batch() { CreatedDate = batchCreatedDate, Id = batchId, GeneticLineId = geneticLineId };

            var standardItem = new StandardItem()
            {
                Sequence = 1,
                StandardGeneticLine =
                    new StandardGeneticLine()
                    {
                        GeneticLineId = geneticLineId,
                        StandardId = standardId
                    }
            };

            var standardItems = new List<StandardItem>() { standardItem }.AsQueryable();

            var standardWithDataTypeWeek = new Standard()
            {
                Id = standardId,
                DataLoadTypeId = new Guid(GlobalConstants.WeeklyDataLoadType)
            };

            Mock.Get(_standardRepository)
                .Setup(x => x.Get(standardId))
                .Returns(standardWithDataTypeWeek);

            Mock.Get(_batchRepository)
                .Setup(x => x.Get(batchId))
                .Returns(batch);

            Mock.Get(_standardItemRepository)
                .Setup(repository => repository.GetAll(It.IsAny<Expression<Func<StandardItem, bool>>>()))
                .Returns(standardItems);

            var outOfScopeMeasureDate = new DateTime(2015, 09, 30);

            _measureService = new MeasureService(_uow, _clock);

            var measures = new List<LoadMeasureModel>() { new LoadMeasureModel()
                                                          {
                                                              BatchId = batchId,
                                                              StandardId = standardId,
                                                              CreatedDate = outOfScopeMeasureDate
                                                          }};

            _measureService.CreateMeasures(measures, batchId);
        }
        public void Create(Standard standard)
        {
            if (!IsNameAvailable(standard.Name, standard.Id))
            {
                throw new ApplicationException("Ya existe un estandar con el mismo nombre");
            }

            Uow.Standards.Add(standard);
            Uow.Commit();
        }
        public void Edit(Standard standard)
        {
            var currentStandard = this.GetById(standard.Id);

            currentStandard.Name = standard.Name;
            currentStandard.DataLoadTypeId = standard.DataLoadTypeId;
            currentStandard.YAxis = standard.YAxis;

            Uow.Standards.Edit(currentStandard);
            Uow.Commit();
        }
        private void ucStandardSelecction_StandardSelected(object sender, Standard standard)
        {
            _stateController.CurrentSelectedStandard = standard;

            if (standard.DataLoadTypeId.ToString() == Avicola.Office.Entities.GlobalConstants.DailyDataLoadType)
            {
                TransitionManager.LoadEnterDailyStandardView();
            }
            else if (standard.DataLoadTypeId.ToString() == Avicola.Office.Entities.GlobalConstants.WeeklyDataLoadType)
            {
                TransitionManager.LoadEnterWeeklyStandardView();
            }
        }
        public void CreateMeasures_WhenThereIsSequenceForTheMeasureCreatedDate_NoException()
        {
            var standardId = Guid.NewGuid();

            var batchId = Guid.NewGuid();

            var geneticLineId = Guid.NewGuid();

            var batchCreatedDate = new DateTime(2015, 09, 09);

            var batch = new Batch() { CreatedDate = batchCreatedDate, Id = batchId, GeneticLineId = geneticLineId };

            var standardItem = new StandardItem()
            {
                Sequence = 1,
                StandardGeneticLine =
                    new StandardGeneticLine()
                    {
                        GeneticLineId = geneticLineId,
                        StandardId = standardId
                    }
            };

            var standardItems = new List<StandardItem>() { standardItem }.AsQueryable();

            var standardWithDataTypeWeek = new Standard()
            {
                Id = standardId,
                DataLoadTypeId = new Guid(GlobalConstants.WeeklyDataLoadType)
            };

            Mock.Get(_standardRepository)
                .Setup(x => x.Get(standardId))
                .Returns(standardWithDataTypeWeek);

            Mock.Get(_batchRepository)
                .Setup(x => x.Get(batchId))
                .Returns(batch);

            Mock.Get(_standardItemRepository)
                .Setup(repository => repository.Get(It.IsAny<Expression<Func<StandardItem, bool>>>()))
                .Returns<Expression<Func<StandardItem, bool>>,
                         Expression<Func<StandardItem, object>>[]>((expression, includes) =>
                                                                   {
                                                                       return standardItems.FirstOrDefault(expression);
                                                                   });

            Mock.Get(_standardItemRepository)
                .Setup(repository => repository.GetAll(It.IsAny<Expression<Func<StandardItem, bool>>>()))
                .Returns(standardItems);

            var validMeasureDate = new DateTime(2015, 09, 16);

            _measureService = new MeasureService(_uow, _clock);

            var measures = new List<LoadMeasureModel>()
                           {
                               new LoadMeasureModel()
                               {
                                   BatchId = batchId,
                                   StandardId = standardId,
                                   CreatedDate = validMeasureDate
                               }
                           };

            _measureService.CreateMeasures(measures, batchId);

            Assert.IsTrue(true);
        }
        public void MaxDateAllowed_WhenStandardContains1WeekItem_Returns1WeekFromTheBatchCreatedDate()
        {
            var standardId = Guid.NewGuid();

            var geneticLineId = Guid.NewGuid();

            var batchCreatedDate = new DateTime(2015, 09, 09);

            var batch = new Batch() { CreatedDate = batchCreatedDate, GeneticLineId = geneticLineId };

            var standardItem = new StandardItem()
                               {
                                   Sequence = 1,
                                   StandardGeneticLine =
                                       new StandardGeneticLine()
                                       {
                                           GeneticLineId = geneticLineId,
                                           StandardId = standardId
                                       }
                               };

            var standardItems = new List<StandardItem>() { standardItem }.AsQueryable();

            var standardWithDataTypeWeek = new Standard()
                                           {
                                               Id = standardId,
                                               DataLoadTypeId = new Guid(GlobalConstants.WeeklyDataLoadType)
                                           };

            Mock.Get(_standardRepository)
                .Setup(x => x.Get(standardId))
                .Returns(standardWithDataTypeWeek);

            Mock.Get(_standardItemRepository)
                .Setup(repository => repository.GetAll(It.IsAny<Expression<Func<StandardItem, bool>>>()))
                .Returns(standardItems);

            _measureService = new MeasureService(_uow, _clock);

            var actualValue = _measureService.MaxDateAllowed(standardId, geneticLineId, batch.CreatedDate);

            DateTime expectedValue = new DateTime(2015, 09, 16);

            Assert.AreEqual(actualValue, expectedValue);
        }
 private void OnStandardSelected(Standard standard)
 {
     if (StandardSelected != null)
     {
         StandardSelected(this, standard);
     }
 }