public Domain.Observation Add(
            IValidationDictionary validationDictionary,
            Domain.Observation observation,
            HttpPostedFileBase postedFile)
        {
            if (!Validate(validationDictionary, observation))
            {
                return(null);
            }

            SetObservationValues(observation);

            var data = _observationRepository.Create();

            _observationRepository.Add(data);

            Mapper.Map(observation, data);

            //Reset the observation ID so that consumers cannot set this.
            data.ObservationId = 0;

            SaveFile(data, postedFile);
            _context.SaveChanges();

            //Map back to the domain so we can use the full
            //result in the web site for sending email, etc.

            return(Mapper.Map <Domain.Observation>(data));
        }
        private static void SetObservationValues(Domain.Observation observation)
        {
            //Currently just map the time from the observation onto to the single
            //date property within the data layer.

            observation.ObservationDate = observation.ObservationDate
                                          .AddHours(observation.ObservationTime.Hour)
                                          .AddMinutes(observation.ObservationTime.Minute);
        }
Exemplo n.º 3
0
        public async Task <Result <Guid> > Handle(CreateObservationCommand request, CancellationToken token)
        {
            if ((request.BatchIds == null || !request.BatchIds.Any()) && (request.ProductIds == null || !request.ProductIds.Any()))
            {
                return(Failure <Guid>("Vous devez préciser au moins un produit ou un lot pour faire une observation."));
            }

            var batches = request.BatchIds != null
                ? await _context.Batches
                          .Where(b => request.BatchIds.Contains(b.Id))
                          .ToListAsync(token)
                : new List <Domain.Batch>();

            var products = request.ProductIds != null
                ? await _context.Products
                           .Where(b => request.ProductIds.Contains(b.Id))
                           .ToListAsync(token)
                : new List <Domain.Product>();

            var batchProducerIds = batches.Select(b => b.ProducerId).Distinct().ToList();

            if (batchProducerIds.Count > 1)
            {
                return(Failure <Guid>("Une observation est liée à un producteur, les lots doivent donc appartenir au même producteur."));
            }

            var productProducerIds = products.Select(b => b.ProducerId).Distinct().ToList();

            if (productProducerIds.Count > 1)
            {
                return(Failure <Guid>("Une observation est liée à un producteur, les produits doivent donc appartenir au même producteur."));
            }

            var producerId = productProducerIds.Any() ? productProducerIds.First() : batchProducerIds.First();
            var producer   = await _context.Producers.SingleOrDefaultAsync(p => p.Id == producerId, token);

            var user = await _context.Users.SingleOrDefaultAsync(u => u.Id == request.RequestUser.Id, token);

            var entity = new Domain.Observation(Guid.NewGuid(), request.Comment, user, producer);

            entity.SetBatches(batches);
            entity.SetProducts(products);
            entity.SetVisibility(request.VisibleToAll);

            await _context.AddAsync(entity, token);

            await _context.SaveChangesAsync(token);

            return(Success(entity.Id));
        }
        public Domain.Observation Edit(
            IValidationDictionary validationDictionary,
            Domain.Observation observation,
            HttpPostedFileBase postedFile)
        {
            if (!Validate(validationDictionary, observation))
            {
                return(null);
            }

            SetObservationValues(observation);

            var data = _observationRepository.GetById(observation.ObservationId);

            data = Mapper.Map(observation, data);

            SaveFile(data, postedFile);
            _context.SaveChanges();

            //Map back to the domain so we can use the full
            //result in the web site for sending email, etc.

            return(Mapper.Map <Domain.Observation>(data));
        }
Exemplo n.º 5
0
 public static ObservationMailerModel GetNotificationData(this Domain.Observation observation, string observationId, string url, string comment, string producerId)
 {
     return(new ObservationMailerModel
     {
         ProducerId = producerId,
         Producer = observation.Producer.Name,
         User = observation.User.Name,
         Comment = comment,
         Batches = observation.Batches?.Select(b => new BatchMailerModel
         {
             Number = b.Batch.Number,
             DDM = b.Batch.DDM,
             DLC = b.Batch.DLC,
         }).ToList() ?? new List <BatchMailerModel>(),
         Products = observation.Products?.Select(b => new ProductMailerModel
         {
             Name = b.Name,
             Reference = b.Reference
         }).ToList() ?? new List <ProductMailerModel>(),
         CreatedOn = observation.CreatedOn,
         ObservationId = observationId,
         PortalUrl = url,
     });
 }
        /// <summary>
        /// Performs field logic that cannot be represented with attributes for an observation.
        /// </summary>
        /// <param name="validationDictionary">A dictionary that will contain the resulting errors</param>
        /// <param name="observation">The observation to validate</param>
        /// <returns><c>true</c> for success, <c>false</c> for failure</returns>
        /// <remarks>
        /// This function should be used in conjunction with the built-in data annotations to validate
        /// simple conditions such as required.
        /// </remarks>

        public bool Validate(IValidationDictionary validationDictionary, Domain.Observation observation)
        {
            var type = _observationTypeRepository.GetById(observation.ObservationTypeId);

            //Email

            if (observation.EmailYesOrNo)
            {
                if (string.IsNullOrWhiteSpace(observation.Email))
                {
                    //Email validation is handled by the [EmailAddress] attribute on the domain
                    validationDictionary.AddError("Email", Domain.Observation.Required);
                }
            }
            else
            {
                validationDictionary.Remove("Email");
                observation.Email = null;
            }

            //Ensure type has a value first, may be a 0 / null type.

            if (type == null)
            {
                validationDictionary.AddError("ObservationTypeId", Domain.Observation.Required);
            }
            else
            {
                //Remove the built-in validation for observation category and other category
                //since we will override the rules to be more specific based on conditional
                //logic here.

                validationDictionary.Remove("ObservationCategoryId");
                validationDictionary.Remove("OtherCategory");

                if (type.Name == Domain.ObservationType.UnsafeCondition)
                {
                    //A category is required if the observation type is "Unsafe Condition"

                    if (!observation.ObservationCategoryId.HasValue)
                    {
                        validationDictionary.AddError("ObservationCategoryId", Domain.Observation.Required);
                    }
                    else
                    {
                        var category = _observationCategoryRepository.GetById(observation.ObservationCategoryId.Value);

                        //If other specified, we need a reason (OtherCategory)

                        if (category.Reference == Domain.ObservationCategory.Other &&
                            string.IsNullOrWhiteSpace(observation.OtherCategory))
                        {
                            validationDictionary.AddError("OtherCategory", Domain.Observation.Required);
                        }
                        else
                        {
                            observation.OtherCategory = null;
                        }
                    }
                }
                else
                {
                    //Remove category Id and other category if "Good Practice" is specified.

                    observation.ObservationCategoryId = null;
                    observation.OtherCategory         = null;
                }
            }

            //Return whether the validation dictionary is valid. This is so that
            //we can extend the result given initially, for required etc.

            return(validationDictionary.IsValid);
        }
Exemplo n.º 7
0
 public static StringContent GetNotificationContent(this Domain.Observation observation, string observationId, string url, string producerId)
 {
     return(new StringContent(JsonConvert.SerializeObject(observation.GetNotificationData(observationId, url, null, producerId)), Encoding.UTF8, "application/json"));
 }