Example #1
0
        public void UpdatePassTest()
        {
            try
            {
                var originalPackItem = getPackItemMock();
                originalPackItem = service.Create(originalPackItem);

                var newPackItem = new PackItemBO();
                newPackItem.Id            = originalPackItem.Id;
                newPackItem.PackingListId = originalPackItem.PackingListId;
                newPackItem.ItemId        = originalPackItem.ItemId;
                newPackItem.Count         = originalPackItem.Count;
                newPackItem.PackingListId = 5;
                newPackItem = service.Update(newPackItem);

                var updatedPackItem = service.Get(originalPackItem.Id);

                Assert.Equal(originalPackItem.Id, newPackItem.Id);

                Assert.Equal(5, newPackItem.PackingListId);

                Assert.Equal(newPackItem.PackingListId, updatedPackItem.PackingListId);

                Assert.NotEqual(originalPackItem.PackingListId, newPackItem.PackingListId);
            }
            catch (Exception e)
            {
                Assert.True(false, e.Message);
            }
            finally
            {
                clearDb();
            }
        }
Example #2
0
        public PackItemBO Update(PackItemBO packItem)
        {
            if (packItem == null)
            {
                return(null);
            }

            using (var uow = _facade.UnitOfWork)
            {
                var packItemEnt = uow.PackItemRepository.Get(packItem.Id);

                if (packItemEnt == null)
                {
                    return(null);
                }

                var packItemUpdated = _conv.ConvertBO(packItem);

                packItemEnt.Id            = packItemUpdated.Id;
                packItemEnt.PackingListId = packItemUpdated.PackingListId;
                packItemEnt.ItemId        = packItemUpdated.ItemId;
                packItemEnt.Count         = packItemUpdated.Count;
                packItemEnt.Packed        = packItemUpdated.Packed;

                uow.Complete();
                return(_conv.Convert(packItemEnt));
            }
        }
 public IActionResult Post([FromBody] PackItemBO packItem)
 {
     if (!ModelState.IsValid)
     {
         return(BadRequest(ModelState));
     }
     return(Ok(_facade.PackItemService.Create(packItem)));
 }
Example #4
0
        public PackItemBO getPackItemMock()
        {
            PackItemBO packItem = new PackItemBO()
            {
                PackingListId = 1,
                ItemId        = 2,
                Count         = 50
            };

            return(packItem);
        }
Example #5
0
        public PackItemBO Create(PackItemBO packItem)
        {
            if (packItem == null)
            {
                return(null);
            }

            using (var uow = _facade.UnitOfWork)
            {
                var createdPackItem = uow.PackItemRepository.Create(_conv.ConvertBO(packItem));
                uow.Complete();
                return(_conv.Convert(createdPackItem));
            }
        }
Example #6
0
 public PackItem ConvertBO(PackItemBO packItemBO)
 {
     if (packItemBO == null)
     {
         return(null);
     }
     return(new PackItem()
     {
         Id = packItemBO.Id,
         PackingListId = packItemBO.PackingListId,
         ItemId = packItemBO.ItemId,
         Count = packItemBO.Count,
         Packed = packItemBO.Packed
     });
 }
 public IActionResult Put(int id, [FromBody] PackItemBO packItem)
 {
     if (id != packItem.Id)
     {
         return(BadRequest("Path ID does not match packItem ID in JSON object."));
     }
     try
     {
         var updatedPackItem = _facade.PackItemService.Update(packItem);
         if (updatedPackItem == null)
         {
             return(StatusCode(404, "No packItem found with that ID"));
         }
         return(Ok(updatedPackItem));
     }
     catch (Exception e)
     {
         return(StatusCode(404, e.Message + "/n" + e.StackTrace));
     }
 }