public async Task <IActionResult> PutHotelRoom(int hotelId, HotelRoomDto hotelRoomDto)
{
if (hotelId != hotelRoomDto.HotelId)
{
return(BadRequest());
}
try
{
await _hotelRoom.UpdateHotelRoom(hotelRoomDto);
}
catch (DbUpdateConcurrencyException)
{
if (!HotelRoomExists(hotelId))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <HotelRoomDto> CreateHotelRoom(HotelRoomDto hotelRoomDto)
{
var hotelRoom = _mapper.Map <HotelsRooms>(hotelRoomDto);
hotelRoom.CreatedDate = DateTime.Now;
hotelRoom.CreatedBy = "";
var addedHotelRoom = await _context.HotelsRooms.AddAsync(hotelRoom);
await _context.SaveChangesAsync();
return(_mapper.Map <HotelRoomDto>(addedHotelRoom.Entity));
}
/// <summary>
/// CREATE: Creates a new Room for a Hotel
/// </summary>
/// <param name="hrDto"></param>
/// <returns></returns>
public async Task <HotelRoom> Create(HotelRoomDto hrDto)
{
HotelRoom hotelRoom = new HotelRoom
{
HotelID = hrDto.HotelID,
RoomID = hrDto.RoomID,
RoomNumber = hrDto.RoomNumber,
Rate = hrDto.Rate,
PetFriendly = hrDto.PetFriendly,
};
_context.Entry(hotelRoom).State = EntityState.Added;
await _context.SaveChangesAsync();
return(hotelRoom);
}
/// <summary>
/// Delete: Deletes a hotel room
/// </summary>
/// <param name="hotelId"></param>
/// <param name="roomNumber"></param>
/// <returns></returns>
public async Task DeleteHotelRoom(int hotelId, int roomNumber)
{
HotelRoomDto hrDto = await GetHotelRoom(hotelId, roomNumber);
HotelRoom hotelRoom = new HotelRoom
{
HotelID = hotelId,
RoomID = hrDto.RoomID,
RoomNumber = roomNumber,
Rate = hrDto.Rate,
PetFriendly = hrDto.PetFriendly,
};
_context.Remove(hotelRoom).State = EntityState.Deleted;
await _context.SaveChangesAsync();
}
public async Task UpdateHotelRoom(HotelRoomDto dto)
{
var hotelRoom = await _context.HotelRooms.Where(x => x.HotelId == dto.HotelId && x.RoomNumber == dto.RoomNumber)
.Include(x => x.Room)
.ThenInclude(x => x.Amenities)
.ThenInclude(x => x.Amenity)
.FirstOrDefaultAsync();
hotelRoom.RoomId = dto.RoomId;
hotelRoom.Rate = dto.Rate;
hotelRoom.PetFriendly = dto.PetFriendly;
_context.Entry(hotelRoom).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public ActionResult GoToHotel(int id)
{
var model = Service.RoomService.hotelRooms();
var hotels = new HotelRoomDto();
foreach (var item in model)
{
if (item.hotelId == id)
{
hotels = item;
break;
}
}
return(View(hotels));
}
public async Task <HotelRoomDto> UpdateHotelRoom(int roomId, HotelRoomDto hotelRoomDto)
{
if (roomId != hotelRoomDto.Id)
{
return(null);
}
var roomFromRepo = await _context.HotelsRooms.FindAsync(roomId);
var updateRoom = _mapper.Map(hotelRoomDto, roomFromRepo);
updateRoom.UpdatedBy = "";
updateRoom.UpdatedDate = DateTime.Now;
_context.HotelsRooms.Update(updateRoom);
await _context.SaveChangesAsync();
return(_mapper.Map <HotelRoomDto>(updateRoom));
}
public async Task <HotelRoomDto> GetHotelRoom(int hotelId, int roomNumber)
{
var hotelRoom = await _context.HotelRooms.Where(x => x.HotelId == hotelId && x.RoomNumber == roomNumber)
.Include(x => x.Room)
.ThenInclude(x => x.Amenities)
.ThenInclude(x => x.Amenity)
.FirstOrDefaultAsync();
HotelRoomDto dto = new HotelRoomDto()
{
HotelId = hotelRoom.HotelId,
RoomNumber = hotelRoom.RoomNumber,
Rate = hotelRoom.Rate,
PetFriendly = hotelRoom.PetFriendly,
RoomId = hotelRoom.RoomId,
Room = await _rooms.GetRoom(hotelRoom.RoomId)
};
return(dto);
}
public async Task <HotelRoomDto> CreateHotelRoom(int hotelId, HotelRoomDto dto)
{
HotelRoom hotelRoom = new HotelRoom()
{
HotelId = hotelId,
RoomNumber = dto.RoomNumber,
RoomId = dto.RoomId,
Rate = dto.Rate,
PetFriendly = dto.PetFriendly,
};
_context.Entry(hotelRoom).State = EntityState.Added;
await _context.SaveChangesAsync();
var hotelDto = await GetHotelRoom(hotelId, dto.RoomNumber);
dto.Room = hotelDto.Room;
return(dto);
}
public async Task <ActionResult <HotelRoomDto> > PostHotelRoom(int hotelId, HotelRoomDto hotelRoomDto)
{
await _hotelRoom.CreateHotelRoom(hotelId, hotelRoomDto);
return(CreatedAtAction("GetHotelRoom", new { id = hotelId }, hotelRoomDto));
}
public async Task <ActionResult <HotelRoom> > PostHotelRoom(HotelRoomDto hotelRoom)
{
await _hotelRoom.Create(hotelRoom);
return(CreatedAtAction("Get HotelRoom", hotelRoom));
}
public void AddRedis()
{
using (BaseRepository <Room> _bR = new BaseRepository <Room>())
{
using (var redisManager = new PooledRedisClientManager())
{
using (var redis = redisManager.GetClient())
{
var myId = SessionSetting.SessionSet <Domain.Domains.Hotel> .Get("LoginHotel").Id;
HotelRoomDto modelList = _bR.Query <Hotel.Domain.Domains.Hotel>().Where(k => k.Id == myId).Select(k => new HotelRoomDto
{
hotelId = myId,
Address = k.Address,
AreaId = k.AreaId,
Email = k.Email,
Gym = k.Gym,
HotelBar = k.HotelBar,
HotelName = k.HotelName,
Park = k.Park,
Pool = k.Pool,
Restaurant = k.Restaurant,
RoomService = k.RoomService,
Spa = k.Spa,
TelNum = k.TelNum,
Terrace = k.Terrace,
WashingMachine = k.WashingMachine,
roomDtos = k.rooms.Where(x => x.OtelId == k.Id).Select(x => new RoomDto
{
airConditioning = x.RoomType.airConditioning,
Bathroom = x.RoomType.Bathroom,
Fund = x.RoomType.Fund,
Jakuzi = x.RoomType.Fund,
Telephone = x.RoomType.Telephone,
MiniBar = x.RoomType.MiniBar,
TV = x.RoomType.TV,
Wifi = x.RoomType.Wifi,
OtelId = myId,
RoomId = x.Id,
Name = x.RoomType.Name,
PersonCount = x.RoomType.PersonCount,
Price = x.Price,
Stock = x.Stock,
roomImageDtos = x.roomImages.Where(a => a.RoomId == x.Id).Select(a => new RoomImageDto
{
IsActive = a.IsActive,
Path = a.Path,
Title = a.Title
}).ToList()
}).ToList()
}).FirstOrDefault();
var data = redis.Get <HotelRoomDto>("otel_cache_" + myId);
if (data != null)
{
redis.Set <HotelRoomDto>("otel_cache_" + myId, modelList);
}
else
{
redis.Add("otel_cache_" + myId, modelList);
}
}
}
}
}
