// public void Post([FromBody] string value)
        public void Post([FromBody] Amenities p_oAmenities)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    Amenities oAmenitiesAdd = new Amenities();

                    oAmenitiesAdd.AmenitiesName = p_oAmenities.AmenitiesName;
                    oAmenitiesAdd.IsActive      = p_oAmenities.IsActive;

                    db.Amenities.Add(oAmenitiesAdd);
                    bIsSuccess = db.SaveChanges() > 0 ? true : false;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
Example #2
0
        public void Post([FromBody] BookingRoom p_oBookingRoom)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    BookingRoom oBookingRoomAdd = new BookingRoom();

                    oBookingRoomAdd.BookingCode  = p_oBookingRoom.BookingCode;
                    oBookingRoomAdd.ClientId     = p_oBookingRoom.ClientId;
                    oBookingRoomAdd.RoomId       = p_oBookingRoom.RoomId;
                    oBookingRoomAdd.CheckInDate  = p_oBookingRoom.CheckInDate;
                    oBookingRoomAdd.CheckOutDate = p_oBookingRoom.CheckOutDate;
                    oBookingRoomAdd.UniqueCode   = p_oBookingRoom.UniqueCode;

                    db.BookingRoom.Add(oBookingRoomAdd);
                    db.SaveChanges();

                    bIsSuccess = true;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
        public void Post([FromBody] Hotel p_oHotel)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    Hotel oHotelAdd = new Hotel();

                    oHotelAdd.HotelName      = p_oHotel.HotelName;
                    oHotelAdd.Address        = p_oHotel.Address;
                    oHotelAdd.Latitude       = p_oHotel.Latitude;
                    oHotelAdd.Longitude      = p_oHotel.Longitude;
                    oHotelAdd.CommissionRate = p_oHotel.CommissionRate;

                    db.Hotel.Add(oHotelAdd);
                    db.SaveChanges();

                    bIsSuccess = true;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
        // public void Post([FromBody] string value)
        public void Post([FromBody] Room p_oRoom)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    Room oRoomAdd = new Room();

                    oRoomAdd.RoomName     = p_oRoom.RoomName;
                    oRoomAdd.HotelId      = p_oRoom.HotelId;
                    oRoomAdd.MaxOccupancy = p_oRoom.MaxOccupancy;
                    oRoomAdd.NetRate      = p_oRoom.NetRate;
                    oRoomAdd.SellRate     = p_oRoom.SellRate;
                    oRoomAdd.CurrencyId   = p_oRoom.CurrencyId;

                    db.Room.Add(oRoomAdd);
                    bIsSuccess = db.SaveChanges() > 0 ? true : false;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
Example #5
0
        // public void Post([FromBody] string value)
        public void Post([FromBody] RoomAmenities p_oRoomAmenities)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    RoomAmenities oRoomAmenitiesAdd = new RoomAmenities();

                    oRoomAmenitiesAdd.RoomId      = p_oRoomAmenities.RoomId;
                    oRoomAmenitiesAdd.AmenitiesId = p_oRoomAmenities.AmenitiesId;

                    db.RoomAmenities.Add(oRoomAmenitiesAdd);
                    bIsSuccess = db.SaveChanges() > 0 ? true : false;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
Example #6
0
        // public void Post([FromBody] string value)
        public void Post([FromBody] Currency p_oCurrency)
        {
            bool bIsSuccess = false;

            using (var oTrans = db.Database.BeginTransaction())
            {
                try
                {
                    Currency oCurrencyAdd = new Currency();

                    oCurrencyAdd.CurrencyCode = p_oCurrency.CurrencyCode;
                    oCurrencyAdd.CurrencyName = p_oCurrency.CurrencyName;
                    oCurrencyAdd.IsActive     = p_oCurrency.IsActive;

                    db.Currency.Add(oCurrencyAdd);
                    bIsSuccess = db.SaveChanges() > 0 ? true : false;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }
        }
Example #7
0
        // public async Task<IActionResult> Create([Bind("RoomId,HotelId,RoomName,MaxOccupancy,NetRate,SellRate,CurrencyId")] Room room)
        public IActionResult Create(vmRoom ovmRoom,
                                    string[] amenitiesChecked
                                    )
        {
            bool bIsSuccess = false;

            Hotel oHotel = _context.Hotel
                           .Include(r => r.Rooms).Where(w => w.HotelId == ovmRoom.oRoom.HotelId).FirstOrDefault();

            if (oHotel.Rooms.Count() >= 2)
            {
                ModelState.AddModelError("oRoom.HotelId", "Maximum limit 5 rooms for 1 hotel.");
            }

            if (ModelState.IsValid)
            {
                using (var oTrans = _context.Database.BeginTransaction())
                {
                    try
                    {
                        _context.Add(ovmRoom.oRoom);
                        _context.SaveChanges();

                        foreach (string Amenities in amenitiesChecked)
                        {
                            RoomAmenities oRoomAmenities = new RoomAmenities();

                            oRoomAmenities.RoomId      = ovmRoom.oRoom.RoomId;
                            oRoomAmenities.AmenitiesId = Convert.ToInt32(Amenities);

                            _context.Add(oRoomAmenities);
                            _context.SaveChanges();
                        }

                        bIsSuccess = true;
                    }
                    catch (Exception Ex)
                    {
                        oTrans.Rollback();
                    }
                    finally
                    {
                        if (bIsSuccess)
                        {
                            oTrans.Commit();
                        }
                    }
                }
            }

            return(RedirectToAction(nameof(Index)));
        }
        public IActionResult DeleteConfirmed(int id)
        {
            bool bIsSuccess = false;

            using (var oTrans = _context.Database.BeginTransaction())
            {
                try
                {
                    Hotel oHotelDeleted = _context.Hotel.Find(id);

                    #region Deleting Child [Room]
                    List <Room> oRoomList = _context.Room.Where(w => w.HotelId == oHotelDeleted.HotelId).ToList();

                    #region Deleting Child [RoomAmenities]
                    foreach (Room i_oRoom in oRoomList)
                    {
                        List <RoomAmenities> oRoomAmenitiesList =
                            _context.RoomAmenities.Where(w => w.RoomId == i_oRoom.RoomId).ToList();

                        _context.RoomAmenities.RemoveRange(oRoomAmenitiesList);
                        _context.SaveChanges();
                    }
                    #endregion

                    _context.Room.RemoveRange(oRoomList);
                    _context.SaveChanges();
                    #endregion

                    _context.Hotel.Remove(oHotelDeleted);
                    _context.SaveChanges();

                    bIsSuccess = true;
                }
                catch (Exception Ex)
                {
                    oTrans.Rollback();
                }
                finally
                {
                    if (bIsSuccess)
                    {
                        oTrans.Commit();
                    }
                }
            }

            return(RedirectToAction(nameof(Index)));
        }