Esempio n. 1
0
        public async Task <IActionResult> UpdateSupply([FromRoute] int id, [FromBody] SupplyDto entityDto)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != entityDto.Id)
            {
                return(BadRequest());
            }

            var entity = await _repository.GetByIdAsync(entityDto.Id);

            if (entity == null)
            {
                return(NotFound("Supply does not exist"));
            }

            _mapper.Map(entityDto, entity);

            try
            {
                _repository.Update(entity);
                await _unitOfWork.SaveAsync();
            }

            catch (Exception)
            {
                throw new Exception("An unexpected error occured. Could not update.");
            }

            return(Ok(_mapper.Map <SupplyDto>(entity)));
        }
Esempio n. 2
0
        public async Task <IActionResult> CreateSupply([FromBody] SupplyDto entityDto)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var entity = _mapper.Map <Supply>(entityDto);

            _repository.Add(entity);

            var itemIds       = entityDto.SupplyItems.Select(s => s.ItemId);
            var locationItems = await _locationItemRepository
                                .GetAsync(l => l.LocationId == entity.LocationId && itemIds.Contains(l.ItemId));

            if (locationItems.Count() != itemIds.Count())
            {
                return(BadRequest("Duplicate item in supply list or an item does not exist"));
            }

            foreach (var item in locationItems)
            {
                item.Quantity -= entity.SupplyItems.Single(s => s.ItemId == item.ItemId).Quantity;
                if (item.Quantity < 0)
                {
                    return(BadRequest(new { message = "Insufficient quantity available", item }));
                }
                _locationItemRepository.Update(item);
            }

            try
            {
                await _unitOfWork.SaveAsync();

                var createdResult = CreatedAtAction("GetSupplyById", new { id = entity.Id }, entity.Id);
                createdResult.StatusCode = 200;
                return(createdResult);
            }
            catch (Exception e)
            {
                throw new Exception("An unexpected error occured. Could not be added.", e);
            }
        }
Esempio n. 3
0
        public void AddSupplyToDB(List <Supply> supplies)
        {
            try
            {
                foreach (var s in supplies)
                {
                    SupplyDto supply = new SupplyDto()
                    {
                        MedicineName = s.MedicineName, PharmacyName = s.PharmacyName, SupplyCount = s.SupplyCount
                    };

                    _supplyRepo.Add(supply);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
 public void AddSupplyToDB(List <Supply> supplies)
 {
     try
     {
         foreach (var s in supplies)
         {
             SupplyDto supply = new SupplyDto()
             {
                 MedicineName = s.MedicineName, PharmacyName = s.PharmacyName, SupplyCount = s.SupplyCount
             };
             _log.Info("Adding supplies to database");
             _supplyRepo.Add(supply);
         }
     }
     catch (Exception e)
     {
         _log.Error("Error while adding supplies to database - " + e.Message);
         throw;
     }
 }
Esempio n. 5
0
 public bool Add(SupplyDto supply)
 {
     _context.Add(supply);
     _context.SaveChanges();
     return(true);
 }
 public void Delete(int id, SupplyDto supply)
 {
     DataService.DeleteSupply(id);
 }
        public IHttpActionResult Post(SupplyDto supply)
        {
            var res = new DtoWithProperties <SupplyDto>(DataService.AddSupply(DtoConverter.SupplyDtoToModel(supply), out Exception ex));

            return(ComposeResult(ex, res));
        }
        public IHttpActionResult Put(SupplyDto supply)
        {
            var res = DataService.UpdateSupply(DtoConverter.SupplyDtoToModel(supply), out Exception ex);

            return(ComposeResult(ex, res));
        }