Пример #1
0
        public IActionResult RemoveFromWishList(WishListToReceive wishListReceived)
        {
            //BookingManager bookingManager = new BookingManager();

            WishListDuplicate wishListToBeRemoved = new WishListDuplicate();

            wishListToBeRemoved.RoomId   = wishListReceived.RoomId;
            wishListToBeRemoved.RenterId = wishListReceived.RenterId;

            Acknowledgement <WishListDuplicate> returnData = new Acknowledgement <WishListDuplicate>();

            if (!ModelState.IsValid)
            {
                returnData = search.WhenErrorOccurs("", type: "modelState");
                return(Ok(returnData));
            }

            try
            {
                // returnData = BookingManager.(wishListReceived);
                returnData = search.DeleteFromWishList(wishListToBeRemoved);
            }
            catch (NotThereInWishList notThereInWishList)
            {
                returnData = search.WhenErrorOccurs(notThereInWishList.Message, type: "delete");  //this will call a overloaded method in bookingManager
                return(Ok(returnData));
            }
            catch (Exception)
            {
                returnData = search.WhenErrorOccurs("", type: "delete");
                return(Ok(returnData));
            }
            return(Ok(returnData));
        }
        public void AddingToWishlist_Negative()
        {
            WishList wishReceived = new WishList();

            wishReceived.WishListId = 1;
            wishReceived.RenterId   = 2;
            wishReceived.RoomId     = 4;


            WishListDuplicate wishListDuplicate = new WishListDuplicate();

            wishListDuplicate.WishListId = 1;
            wishListDuplicate.RenterId   = 2;
            wishListDuplicate.RoomId     = 4;

            List <WishListDuplicate> returnedWishlist = new List <WishListDuplicate>();

            returnedWishlist.Add(wishListDuplicate);
            //Arrange
            var _mockDataService = new Mock <BookingService>();

            _mockDataService.Setup(p => p.AddingToWishList(wishReceived)).Throws <System.Exception>();
            var _bookingManager = new BookingManager(_mockDataService.Object);

            try
            {
                var responseReturned = _bookingManager.AddingToWishList(wishReceived);
                Assert.IsTrue(false);
            }
            catch
            {
                Assert.IsTrue(true);
            }
        }
        public void DeleteFromWishList_Negative()
        {
            int renterId = 2;

            WishListDuplicate wishListDuplicateReceieved = new WishListDuplicate
            {
                RenterId = 2,
                RoomId   = 3
            };
            Acknowledgement <WishListDuplicate> wishlistAcknowledgement = new Acknowledgement <WishListDuplicate>();

            wishlistAcknowledgement.code    = 0;
            wishlistAcknowledgement.Set     = null;
            wishlistAcknowledgement.Message = "fail";


            //Arrange
            var _mockDataService = new Mock <BookingService>();


            _mockDataService.Setup(p => p.RemoveFromWishList(wishListDuplicateReceieved)).Throws <System.Exception>();

            var _bookingManager = new BookingManager(_mockDataService.Object);

            try
            {
                var responseReturned = _bookingManager.DeleteFromWishList(wishListDuplicateReceieved);
                Assert.IsTrue(false);
            }
            catch
            {
                Assert.IsTrue(true);
            }
        }
Пример #4
0
        public virtual Acknowledgement <WishListDuplicate> AddingToWishList(WishList wishListReceived)
        {
            WishListDuplicate                   wishListDuplicate;
            List <WishListDuplicate>            WishlistDuplicateList = new List <WishListDuplicate>();
            Acknowledgement <WishListDuplicate> returnData;
            // BookingService bookingService = new BookingService();
            List <Room> roomsInWishList = new List <Room>();

            try
            {
                roomsInWishList = bookingService.DisplayWishList(wishListReceived.RenterId);
                foreach (var v in roomsInWishList)
                {
                    if (v.RoomId == wishListReceived.RoomId)
                    {
                        throw new AlreadyThereInWishList(wishListReceived.RoomId);
                    }
                }
                bookingService.AddingToWishList(wishListReceived);
                wishListDuplicate = new WishListDuplicate(wishListReceived.WishListId, wishListReceived.RenterId, wishListReceived.RoomId);
                WishlistDuplicateList.Add(wishListDuplicate);
                returnData = new Acknowledgement <WishListDuplicate>(1, WishlistDuplicateList, "Added to wishlist");
            }
            catch (AlreadyThereInWishList alreadyThere)
            {
                throw alreadyThere;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return(returnData);
        }
        public void DeleteFromWishList_Positive()
        {
            int renterId = 2;

            WishListDuplicate wishListDuplicateReceieved = new WishListDuplicate
            {
                RenterId = 2,
                RoomId   = 3
            };

            WishListDuplicate wishListDuplicateSent = new WishListDuplicate
            {
                WishListId = 1,
                RenterId   = 2,
                RoomId     = 3
            };


            List <WishListDuplicate> wishlistList = new List <WishListDuplicate>();

            wishlistList.Add(wishListDuplicateSent);

            Acknowledgement <WishListDuplicate> wishlistAcknowledgement = new Acknowledgement <WishListDuplicate>();

            wishlistAcknowledgement.code    = 1;
            wishlistAcknowledgement.Set     = wishlistList;
            wishlistAcknowledgement.Message = "success";


            //Arrange
            var _mockDataService = new Mock <BookingService>();


            _mockDataService.Setup(p => p.RemoveFromWishList(wishListDuplicateReceieved)).Returns(wishlistList);

            var _bookingManager = new BookingManager(_mockDataService.Object);

            try
            {
                var responseReturned = _bookingManager.DeleteFromWishList(wishListDuplicateReceieved);
                Assert.IsTrue(false);
            }
            catch
            {
                Assert.IsTrue(true);
            }
        }
        private Acknowledgement <WishListDuplicate> RemoveFromWishList_Mock_Positive()
        {
            WishListDuplicate wishListDuplicate = new WishListDuplicate
            {
                WishListId = 1, RenterId = 2, RoomId = 4
            };
            List <WishListDuplicate> wishList = new List <WishListDuplicate>();

            wishList.Add(wishListDuplicate);
            var wishList_Ack = new Acknowledgement <WishListDuplicate>
            {
                code    = 1,
                Set     = wishList,
                Message = "Success "
            };

            return(wishList_Ack);
        }
Пример #7
0
        public virtual Acknowledgement <WishListDuplicate> DeleteFromWishList(WishListDuplicate wishListDuplicateReceived)
        {
            Acknowledgement <WishListDuplicate> returnData;
            List <WishListDuplicate>            wishListDuplicateRooms = new List <WishListDuplicate>();

            try
            {
                // wishListDuplicateRooms = bookingService.RemoveFromWishList(wishListDuplicateReceived);
                wishListDuplicateRooms = bookingService.RemoveFromWishList(wishListDuplicateReceived);
                returnData             = new Acknowledgement <WishListDuplicate>(1, wishListDuplicateRooms, "Removed from wishlist");
            }
            catch (NotThereInWishList notThere)
            {
                throw notThere;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(returnData);
        }
Пример #8
0
        //   public static void RemoveFromWishList(int renterIdReceived, int roomIdReceived)
        public virtual List <WishListDuplicate> RemoveFromWishList(WishListDuplicate wishListDuplicateReceived)
        {
            //  List<Room> WishListRooms;

            int wishListId;
            //   FindMyRoomDb fmrDb = new FindMyRoomDb();
            WishList                 wishListToBeDeleted = new WishList();
            WishListDuplicate        wishListDuplicate;
            List <WishListDuplicate> wishListDuplicateList = new List <WishListDuplicate>();

            try
            {
                //            select* from FMRRooms r, FMRWishLists W
                //WHERE W.RenterId = 1 and w.RoomId = r.RoomId

                wishListId = (from r in fmrDb.FMRWishLists
                              where (r.RenterId == wishListDuplicateReceived.RenterId) && (r.RoomId == wishListDuplicateReceived.RoomId)
                              select r.WishListId).FirstOrDefault();
                if ((wishListId == null) || (wishListId == 0))
                {
                    throw new NotThereInWishList(wishListDuplicateReceived.RoomId, wishListDuplicateReceived.RenterId);
                }
                wishListToBeDeleted = fmrDb.FMRWishLists.Find(wishListId);
                fmrDb.FMRWishLists.Remove(wishListToBeDeleted);
                fmrDb.SaveChanges();
                wishListDuplicate = new WishListDuplicate(wishListToBeDeleted.WishListId, wishListToBeDeleted.RenterId, wishListToBeDeleted.RoomId);
                wishListDuplicateList.Add(wishListDuplicate);
            }

            catch (NotThereInWishList notThere)
            {
                throw notThere;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(wishListDuplicateList);
        }