Ejemplo n.º 1
0
        public IHttpActionResult Post([FromBody] List <CreateRestriction> command)
        {
            if (!ModelState.IsValid)
            {
                return(this.Error().InvalidParameters());
            }

            Restriction restriction = null;
            var         returnList  = new List <Restriction>();

            foreach (var item in command)
            {
                ValidateInput(item);
                var refItem = item;
                AssignDefaultValue(ref refItem);
                restriction     = _mapper.Map <Restriction>(refItem);
                restriction.Uid = Guid.NewGuid();
                EnsureThatAllSalesAreasAdded(restriction);

                _restrictionRepository.Add(restriction);
                returnList.Add(restriction);
            }

            _restrictionRepository.SaveChanges();
            return(Ok(_mapper.Map <List <RestrictionModel> >(returnList)));
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> GlobalRestrict([FromBody] GlobalRestrictionRequestModel requestModel)
        {
            try
            {
                var employees = await _restrictionRepository.GetAll();

                foreach (var employee in employees)
                {
                    if (!requestModel.GlobalDayLimit.HasValue)
                    {
                        return(BadRequest("Missing global day limit value"));
                    }
                    employee.GlobalDayLimit = requestModel.GlobalDayLimit.Value;

                    _restrictionRepository.Update(employee);
                }

                await _restrictionRepository.SaveChanges();

                return(Ok());
            }
            catch (Exception e)
            {
                return(BadRequest(e.Message));
            }
        }
        public override void Handle(IBulkRestrictionCreatedOrUpdated command)
        {
            if (command.Data.Any())
            {
                var newRestrictionModelItems = command.Data.ToList();

                ValidateNewRestrictions(newRestrictionModelItems);

                var salesAreas = newRestrictionModelItems.SelectMany(x => x.SalesAreas)
                                 .Select(x => x.Trim())
                                 .Distinct()
                                 .ToList();

                _salesAreaRepository.ValidateSalesArea(salesAreas);

                var programmeCategoryNames = newRestrictionModelItems
                                             .Select(x => x.ProgrammeCategory)
                                             .Distinct(StringComparer.OrdinalIgnoreCase).ToList();

                _programmeCategoryRepository.ValidateProgrammeCategory(programmeCategoryNames);

                var clearenceCodes = newRestrictionModelItems
                                     .Where(x => !string.IsNullOrWhiteSpace(x.ClearanceCode))
                                     .Select(x => x.ClearanceCode)
                                     .Distinct(StringComparer.OrdinalIgnoreCase).ToList();

                ValidateClearanceCodes(clearenceCodes);

                var newRestrictions = _mapper.Map <List <RestrictionDbObject> >(newRestrictionModelItems);

                var allSalesAreaQty = _salesAreaRepository.CountAll;
                foreach (var newRestriction in newRestrictions)
                {
                    newRestriction.Uid = Guid.NewGuid();

                    if ((newRestriction.SalesAreas?.Any() ?? false) &&
                        newRestriction.SalesAreas.Count == allSalesAreaQty)
                    {
                        newRestriction.SalesAreas = new List <string>();
                    }
                }

                _restrictionRepository.UpdateRange(newRestrictions);
                _restrictionRepository.SaveChanges();
            }
        }