/// <summary>
/// Update tax details
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="resultHotel"></param>
/// <param name="hotel"></param>
/// <returns></returns>
private async Task UpdateTaxDetails(HotelDetailsViewModel hotelVm, BaseResult <List <Hotel> > resultHotel, Hotel hotel)
{
var hotelTaxListCreate = new List <HotelTaxRelationViewModel>();
var hotelTaxListModified = new List <HotelTaxRelationViewModel>();
foreach (var item in hotelVm.TaxDetails)
{
if (item.ObjectState == ObjectState.Added)
{
item.HotelId = hotel.Id;
hotelTaxListCreate.Add(item);
}
else if (item.ObjectState == ObjectState.Modified)
{
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.HotelId, hotelVm.HotelId);
param.Add(Constants.StoredProcedureParameters.TaxTypeId, item.TaxTypeId);
param.Add(Constants.StoredProcedureParameters.TaxApplicabilityId, item.TaxApplicabilityId);
param.Add(Constants.StoredProcedureParameters.Amount, item.Amount);
param.Add(Constants.StoredProcedureParameters.IsIncludedInRates, item.IsIncludedInRates);
param.Add(Constants.StoredProcedureParameters.IsDeleted, item.IsDeleted);
await iHotelTaxRelation.ExecuteStoredProcedureDynamicModel(Constants.StoredProcedure.SaveUpdateHotelTaxRelation, param).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
hotelTaxListModified.Add(item);
}
}
if (hotelTaxListCreate.Count > 0)
{
await this.CreateHotelTaxRelation(hotelTaxListCreate).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
}
}
public static ContractHotel AutomapperContractHotel(HotelDetailsViewModel hotelDetailsViewModel, string loggedUser)
{
var mappedModel = AutoMapper.Mapper.Map <ContractHotel>(hotelDetailsViewModel);
ResolveRemainingParamters(mappedModel, hotelDetailsViewModel, loggedUser);
return(mappedModel);
}
public ActionResult AddHotel(HotelDetailsViewModel hotelDetailsViewModel, List <HttpPostedFileBase> files)
{
if (true)
{
hotelDetailsViewModel.Hotel.HotelImage = new List <HotelImage>();
//HttpPostedFileBase file = Request.Files["ProfilePicture"];
var path = SaveFileToDirectory(Request.Files["ProfilePicture"]);
hotelDetailsViewModel.Hotel.ProfilePicSource = path;
hotelDetailsViewModel.Hotel.HotelImage.Add(new HotelImage
{
ImageSource = path
});
foreach (var file in files)
{
path = SaveFileToDirectory(file);
hotelDetailsViewModel.Hotel.HotelImage.Add(new HotelImage
{
ImageSource = path
});
}
_hotelService.AddHotel(hotelDetailsViewModel);
}
ViewBag.DestinationId = new SelectList(_destinationService.GetAll(), "Id", "Name");
ViewBag.RoomTypeId = new SelectList(_hotelService.GetAllRoomTypes(), "Id", "TypeName");
/*return View();*/
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// hotel Automapper
/// </summary>
/// <param name="hotelViewModel"></param>
/// <param name="hotelDatabase"></param>
/// <returns>mapped hotel</returns>
public static Hotel AutomapperHotel(HotelDetailsViewModel hotelViewModel, Hotel hotelDatabase, string LoggedInUserName)
{
var hotelMapped = AutoMapper.Mapper.Map <Hotel>(hotelViewModel);
ResolveRemainingParamters(hotelMapped, hotelDatabase, LoggedInUserName);
return(hotelMapped);
}
public HotelDetailsViewModel GetHotelDetails(int hotelId)
{
HotelDetailsViewModel hotelDetails = new HotelDetailsViewModel();
using (var dbContext = new HotelAdvisorContext())
{
Hotel hotel = dbContext.Hotels.Include(h => h.Comments)
.FirstOrDefault(h => h.Id == hotelId);
hotelDetails =
new HotelDetailsViewModel()
{
HotelName = hotel.Name,
HotelId = hotel.Id,
AverageRating = hotel.Comments.Count() == 0 ? 0 : hotel.Comments.Average(c => c.Rating),
TotalReviews = hotel.Comments.Count(),
Image = hotel.Image,
Comments = hotel.Comments.Select(co => new CommentViewModel()
{
UserName = co.User.UserName,
Text = co.Text,
Title = co.Title,
DateAdded = co.DateAdded,
Rating = co.Rating,
Id = co.Id
}).ToList()
};
}
return(hotelDetails);
}
public IActionResult GetHotelById(int hotelId)
{
List <SelectListItem> hotelRoomNames = new List <SelectListItem>();
foreach (HotelRoom hotelRoom in _context.HotelRooms.Where(hr => hr.HotelId == hotelId).ToList())
{
hotelRoomNames.Add(new SelectListItem(hotelRoom.Name, hotelRoom.Id.ToString()));
}
List <SelectListItem> foodCategories = new List <SelectListItem>();
foreach (TourFoodCategory foodCategory in _context.TourFoodCategories.Where(fc => _context.Tours.Where(t => t.HotelRoom.HotelId == hotelId).Select(t => t.TourFoodCategory).Contains(fc)).ToList())
{
foodCategories.Add(new SelectListItem(string.Join(' ', foodCategory.ShortName, foodCategory.FullName), foodCategory.Id.ToString()));
}
HotelDetailsViewModel model = new HotelDetailsViewModel
{
Hotel = _context.Hotels.FirstOrDefault(h => h.Id == hotelId),
HotelRooms = _context.HotelRooms.Where(hr => hr.HotelId == hotelId).ToList(),
FoodCategories = foodCategories,
HotelRoomNames = hotelRoomNames
};
return(PartialView("_HotelDetails", model));
}
public ActionResult Details(int id)
{
HotelManager manager = new HotelManager();
HotelDetailsViewModel model = manager.GetHotelDetails(id);
return(View(model));
}
internal void AddHotel(HotelDetailsViewModel hotelDetailsViewModel)
{
_db.Hotels.Add(hotelDetailsViewModel.Hotel);
_db.SaveChanges();
/*foreach (var image in hotelDetailsViewModel.Hotel.HotelImage)
* {
* image.HotelId = hotelDetailsViewModel.Hotel.Id;
* _db.HotelImages.Add(image);
* }*/
_db.SaveChanges();
var hotelId = hotelDetailsViewModel.Hotel.Id;
hotelDetailsViewModel.HotelService.HotelId = hotelId;
_db.HotelServices.Add(hotelDetailsViewModel.HotelService);
hotelDetailsViewModel.HotelPolicy.HotelId = hotelId;
_db.HotelPolicies.Add(hotelDetailsViewModel.HotelPolicy);
foreach (var rooms in hotelDetailsViewModel.Rooms)
{
rooms.HotelId = hotelId;
_db.Rooms.Add(rooms);
}
_db.SaveChanges();
}
public static ContractHotel MapToContractHotelModel(HotelDetailsViewModel source, string userName)
{
var dest = AutoMapper.Mapper.Map <ContractHotel>(source);
dest.UpdatedBy = dest.CreatedBy = userName;
dest.UpdatedDate = dest.CreatedDate = DateTime.Now.JakartaOffset();
return(dest);
}
public static ContractEmailReservation MapToContractEmailReservationModel(HotelDetailsViewModel source, int contractId, string userName)
{
var dest = AutoMapper.Mapper.Map <ContractEmailReservation>(source);
dest.ContractId = contractId;
dest.CreatedBy = dest.UpdatedBy = userName;
dest.CreatedDate = dest.UpdatedDate = DateTime.Now.JakartaOffset();
return(dest);
}
public static void ResolveRemainingParamters(ContractHotel destination, HotelDetailsViewModel source, string loggedUser)
{
destination.Code = source.HotelCode;
destination.Name = source.HotelName;
destination.CreatedBy = loggedUser;
destination.UpdatedBy = loggedUser;
destination.CreatedDate = DateTime.Now.JakartaOffset();
destination.UpdatedDate = DateTime.Now.JakartaOffset();
}
public HotelDetailsViewModel GetHotelDetails(int id)
{
var detailedHotels = new HotelDetailsViewModel
{
Hotel = _db.Hotels.Include("HotelImage").FirstOrDefault(_ => _.Id == id),
HotelPolicy = _db.HotelPolicies.FirstOrDefault(_ => _.HotelId == id),
HotelService = _db.HotelServices.FirstOrDefault(_ => _.HotelId == id),
Rooms = _db.Rooms.Where(_ => _.HotelId == id).Include("RoomType").ToList()
};
return(detailedHotels);
}
public static BaseResult <string> ValidateModelHotelCreate(HotelDetailsViewModel model)
{
BaseResult <string> validationResult = new BaseResult <string>();
if (String.IsNullOrEmpty(model.HotelName))
{
validationResult.Message = model.HotelName;
validationResult.IsError = true;
return(validationResult);
}
else if (model.HotelTypeId <= 0)
{
validationResult.Message = Convert.ToString(model.HotelTypeId);
validationResult.IsError = true;
return(validationResult);
}
else if (model.CountryId <= 0)
{
validationResult.Message = Convert.ToString(model.CountryId);
validationResult.IsError = true;
return(validationResult);
}
else if (model.CityId <= 0)
{
validationResult.Message = Convert.ToString(model.CityId);
validationResult.IsError = true;
return(validationResult);
}
else if (model.Latitude.GetType() != typeof(decimal))
{
validationResult.Message = Convert.ToString(model.Latitude);
validationResult.IsError = true;
return(validationResult);
}
else if (model.Latitude.GetType() != typeof(decimal))
{
validationResult.Message = Convert.ToString(model.Longitude);
validationResult.IsError = true;
return(validationResult);
}
else if (String.IsNullOrEmpty(model.ShortDescription))
{
validationResult.Message = model.ShortDescription;
validationResult.IsError = true;
return(validationResult);
}
validationResult.IsError = false;
return(validationResult);
}
/// <summary>
/// create reservation emails
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="editMode"></param>
/// <returns></returns>
public async Task <BaseResult <long> > CreateAndUpdateReservationEmail(HotelDetailsViewModel hotelVm, bool editMode)
{
if (hotelVm.ReservationEmail == null)
{
return(null);
}
List <string> lstEmail = hotelVm.ReservationEmail.Split(",").ToList();
List <EmailReservation> lstEmailReservations = new List <EmailReservation>();
if (editMode)
{
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.HotelId, hotelVm.HotelId);
await iHotelTaxRelation.ExecuteStoredProcedureDynamicModel(Constants.StoredProcedure.UpdateReservationEmail, param).ConfigureAwait(false);
foreach (var item in lstEmail)
{
EmailReservation email = new EmailReservation
{
HotelId = hotelVm.HotelId,
Email = item
};
lstEmailReservations.Add(email);
}
return(await iEmailReservation.InsertEntityList(lstEmailReservations).ConfigureAwait(false));
}
else
{
foreach (var item in lstEmail)
{
EmailReservation email = new EmailReservation
{
HotelId = hotelVm.HotelId,
Email = item
};
lstEmailReservations.Add(email);
}
return(await iEmailReservation.InsertEntityList(lstEmailReservations).ConfigureAwait(false));
}
}
public async Task <IActionResult> CreateHotel([FromBody] HotelDetailsViewModel Hotels)
{
if (Hotels == null)
{
return(BadRequest());
}
var LoggedInUserName = this.LoggedInUserName;
var result = await this.iHotel.SaveAndUpdateHotelInfo(Hotels, LoggedInUserName).ConfigureAwait(false);
if (result.IsError && result.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
//else if (result.Result == null || result.Result.Count() == 0)
//{
// return NoContent(); //204
//}
return(Created(Url.RouteUrl(result.Result[0].Id), result.Result[0].Id));
}
/// <summary>
/// update payment method relation
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="resultHotel"></param>
/// <param name="hotel"></param>
/// <returns></returns>
private async Task UpdatePaymentMethodRelation(HotelDetailsViewModel hotelVm, BaseResult <List <Hotel> > resultHotel, Hotel hotel)
{
var paymentDbList = iHotelPaymentMethodRelation.GetList().Result.Result;
if (hotelVm.HotelPaymentMethodRelation.ObjectState == ObjectState.Added)
{
hotelVm.HotelPaymentMethodRelation.HotelId = hotel.Id;
await this.CreateHotelPaymentMethodRelation(hotelVm.HotelPaymentMethodRelation).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
}
else if (hotelVm.HotelPaymentMethodRelation.ObjectState == ObjectState.Modified)
{
var paymentDb = paymentDbList.Where(p => p.Id == hotelVm.HotelPaymentMethodRelation.HotelPaymentMethodRelationId).FirstOrDefault();
paymentDb.HotelId = hotel.Id;
HotelPaymentMethodRelation payment = DbMapperMasterdata.AutomapperPaymentMethodRelation(hotelVm.HotelPaymentMethodRelation, paymentDb);
await iHotelPaymentMethodRelation.UpdateEntityByDapper(payment).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
}
}
/// <summary>
/// create reservation telephone
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="editMode"></param>
/// <returns></returns>
public async Task <BaseResult <long> > CreateAndUpdateReservationTelephone(HotelDetailsViewModel hotelVm, bool editMode)
{
if (hotelVm.ReservationContactNo == null)
{
return(null);
}
List <string> lstTelephoneNumbers = hotelVm.ReservationContactNo.Split(",").ToList();
List <TelephoneReservation> lstTelephoneReservations = new List <TelephoneReservation>();
if (editMode)
{
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.HotelId, hotelVm.HotelId);
await iHotelTaxRelation.ExecuteStoredProcedureDynamicModel(Constants.StoredProcedure.UpdateReservationTelephone, param).ConfigureAwait(false);
foreach (var item in lstTelephoneNumbers)
{
TelephoneReservation telephone = new TelephoneReservation
{
HotelId = hotelVm.HotelId,
Telephone = item
};
lstTelephoneReservations.Add(telephone);
}
return(await iTelephoneReservation.InsertEntityList(lstTelephoneReservations).ConfigureAwait(false));
}
else
{
foreach (var item in lstTelephoneNumbers)
{
TelephoneReservation telephone = new TelephoneReservation
{
HotelId = hotelVm.HotelId,
Telephone = item
};
lstTelephoneReservations.Add(telephone);
}
return(await iTelephoneReservation.InsertEntityList(lstTelephoneReservations).ConfigureAwait(false));
}
}
/// <summary>
/// update hotel
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="LoggedInUserName"></param>
/// <param name="resultHotel"></param>
/// <param name="hotel"></param>
/// <returns></returns>
private async Task <Hotel> UpdateHotel(HotelDetailsViewModel hotelVm, string LoggedInUserName, BaseResult <List <Hotel> > resultHotel, Hotel hotel)
{
var hotelDb = iConnectionLibrary.GetList().Result.Result.Where(p => p.Id == hotelVm.HotelId).FirstOrDefault();
if (hotelVm.ObjectState == ObjectState.Added)
{
var res = await this.CreateHotel(hotelVm, LoggedInUserName).ConfigureAwait(false);
hotelVm.HotelId = res.Result[0].Id;
await this.CreateAndUpdateReservationEmail(hotelVm, false).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
await this.CreateAndUpdateReservationTelephone(hotelVm, false).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
hotel.Id = res.Result[0].Id;
}
else if (hotelVm.ObjectState == ObjectState.Modified)
{
hotel = DbMapperMasterdata.AutomapperHotel(hotelVm, hotelDb, LoggedInUserName);
await iConnectionLibrary.UpdateEntityByDapper(hotel as Hotel).ConfigureAwait(false);
await this.CreateAndUpdateReservationEmail(hotelVm, true).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
await this.CreateAndUpdateReservationTelephone(hotelVm, true).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
resultHotel.Result.Add(hotel);
}
return(hotel);
}
public HotelDetailsViewModel GetHotelDetails(int hotelId)
{
HotelDetailsViewModel hotelDetails = new HotelDetailsViewModel();
using (var context = new HotelAdvisorContext())
{
hotelDetails = context.Hotels.Where(h => h.Id == hotelId).Include(h => h.Comments).Select(
s => new HotelDetailsViewModel()
{
HotelId = s.Id,
HotelName = s.Name,
City = s.City,
Description = s.Description,
Address = s.Address,
Image = s.Image,
TotalReveiws = s.Comments.Count(),
AverageRating = (s.Comments.Count() == 0) ? 0 : s.Comments.Average(c => c.Rating),
Comments = s.Comments.ToList()
}).FirstOrDefault();
}
return(hotelDetails);
}
/// <summary>
/// update contacts
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="LoggedInUserName"></param>
/// <param name="resultHotel"></param>
/// <param name="hotel"></param>
/// <returns></returns>
private async Task UpdateContacts(HotelDetailsViewModel hotelVm, string LoggedInUserName, BaseResult <List <Hotel> > resultHotel, Hotel hotel)
{
var contactDbList = iContact.GetListByPredicate(x => x.HotelId == hotelVm.HotelId).Result.Result;
foreach (var item in hotelVm.ContactDetails)
{
if (item.ObjectState == ObjectState.Added)
{
item.HotelId = hotel.Id;
await this.CreateContacts(item, LoggedInUserName).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
}
else if (item.ObjectState == ObjectState.Modified)
{
var contactDb = contactDbList.Where(p => p.Id == item.ContactId).FirstOrDefault();
contactDb.HotelId = hotelVm.HotelId;
Contacts contact = DbMapperMasterdata.AutomapperContacts(item, contactDb, LoggedInUserName);
await iContact.UpdateEntityByDapper(contact).ConfigureAwait(false);
resultHotel.Result.Add(hotel);
}
}
}
/// <summary>
/// create and update hotel info
/// </summary>
/// <param name="hotelVm"></param>
/// <param name="LoggedInUserName"></param>
/// <returns></returns>
public async Task <BaseResult <List <Hotel> > > SaveAndUpdateHotelInfo(HotelDetailsViewModel hotelVm, string LoggedInUserName)
{
BaseResult <List <Hotel> > resultHotel = new BaseResult <List <Hotel> >();
resultHotel.Result = new List <Hotel>();
Hotel hotel = new Hotel()
{
Id = hotelVm.HotelId
};
BaseResult <long> result = new BaseResult <long>();
#region hotel operations
hotel = await UpdateHotel(hotelVm, LoggedInUserName, resultHotel, hotel).ConfigureAwait(false);
#endregion hotel operations
#region contacts operations
await UpdateContacts(hotelVm, LoggedInUserName, resultHotel, hotel).ConfigureAwait(false);
#endregion contacts operations
#region tax details
await UpdateTaxDetails(hotelVm, resultHotel, hotel).ConfigureAwait(false);
#endregion tax details
#region payment method relation
await UpdatePaymentMethodRelation(hotelVm, resultHotel, hotel).ConfigureAwait(false);
#endregion payment method relation
resultHotel.Result.Add(hotel);
return(resultHotel);
}
/// <summary>
/// Get hotel by hotel id
/// </summary>
/// <param name="id"></param>
/// <returns>A Task representing the asynchronous operation.</returns>
public async Task <IActionResult> GetHotel(int id)
{
if (id <= 0)
{
return(BadRequest());
}
BaseResult <List <HotelView> > hotelResult = await iHotel.GetHotel(id).ConfigureAwait(false);
if (hotelResult.Result == null || !hotelResult.Result.Any())
{
if (hotelResult.IsError && hotelResult.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (hotelResult.Result == null || !hotelResult.Result.Any())
{
return(NoContent()); //204
}
}
HotelDetailsViewModel hotels = HotelManagementResponseMapper.MapHotelDetailsToHotelDetailsViewModel(hotelResult);
return(Ok(hotels));
}
public IActionResult Details(int id)
{
HotelDetailsViewModel viewMode = this.hotelsServices.GetHotelDetails(id);
return(this.View(viewMode));
}
/// <summary>
/// Create Hotel
/// </summary>
/// <param name="hotel"></param>
/// <returns></returns>
public async Task <BaseResult <List <Hotel> > > CreateHotel(HotelDetailsViewModel hotel, string LoggedInUserName)
{
BaseResult <List <Hotel> > result = new BaseResult <List <Hotel> >();
//// Add hotel Details
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.Name, hotel.HotelName);
param.Add(Constants.StoredProcedureParameters.CityId, hotel.CityId);
param.Add(Constants.StoredProcedureParameters.Longitude, hotel.Longitude);
param.Add(Constants.StoredProcedureParameters.Latitude, hotel.Latitude);
param.Add(Constants.StoredProcedureParameters.StarRating, hotel.StarRatingId);
param.Add(Constants.StoredProcedureParameters.IsActive, hotel.IsActive);
param.Add(Constants.StoredProcedureParameters.HotelBrandId, hotel.HotelBrandId);
param.Add(Constants.StoredProcedureParameters.ShortDescription, hotel.ShortDescription);
param.Add(Constants.StoredProcedureParameters.LongDescription, hotel.LongDescription);
param.Add(Constants.StoredProcedureParameters.CreatedBy, LoggedInUserName);
param.Add(Constants.StoredProcedureParameters.CreatedDate, DateTime.Now.JakartaOffset());
param.Add(Constants.StoredProcedureParameters.UpdatedBy, LoggedInUserName);
param.Add(Constants.StoredProcedureParameters.UpdatedDate, DateTime.Now.JakartaOffset());
param.Add(Constants.StoredProcedureParameters.Website, hotel.Website);
param.Add(Constants.StoredProcedureParameters.HotelTypeId, hotel.HotelTypeId);
param.Add(Constants.StoredProcedureParameters.IsExtranetAccess, hotel.IsExtranetAccess);
param.Add(Constants.StoredProcedureParameters.IsChannelManagerConnectivity, hotel.IsChannelManagerConnectivity);
if (hotel.ChannelManagerId == 0)
{
hotel.ChannelManagerId = null;
}
param.Add(Constants.StoredProcedureParameters.ChannelManagerId, hotel.ChannelManagerId);
param.Add(Constants.StoredProcedureParameters.CountryId, hotel.CountryId);
param.Add(Constants.StoredProcedureParameters.Address1, hotel.Address1);
param.Add(Constants.StoredProcedureParameters.Address2, hotel.Address2);
param.Add(Constants.StoredProcedureParameters.ZipCode, hotel.ZipCode);
param.Add(Constants.StoredProcedureParameters.MGPoints, hotel.MGPoint);
param.Add(Constants.StoredProcedureParameters.ChainId, hotel.HotelChainId);
if (!string.IsNullOrEmpty(hotel.CheckInFrom))
{
bool res = DateTime.TryParse(hotel.CheckInFrom, out DateTime dt);
if (res)
{
param.Add(Constants.StoredProcedureParameters.CheckInFrom, dt.TimeOfDay);
}
}
if (!string.IsNullOrEmpty(hotel.CheckOutTo))
{
bool res = DateTime.TryParse(hotel.CheckOutTo, out DateTime dt);
if (res)
{
param.Add(Constants.StoredProcedureParameters.CheckOutTo, dt.TimeOfDay);
}
}
else
{
param.Add(Constants.StoredProcedureParameters.CheckOutTo, null);
}
param.Add(Constants.StoredProcedureParameters.TotalNumberOfRooms, hotel.TotalNumberOfRooms);
result = await iConnectionLibrary.ExecuteStoredProcedure(Constants.StoredProcedure.AddHotel, param).ConfigureAwait(false);
if (result.IsError)
{
return(result);
}
return(result);
}
public void AddHotel(HotelDetailsViewModel hotelDetailsViewModel)
{
_hotelRepository.AddHotel(hotelDetailsViewModel);
}
/// <summary>
/// Returns Mapped Hotel Details view Model
/// </summary>
/// <param name="hoteldata"></param>
/// <returns> Mapped Hotel Details view Model</returns>
public static HotelDetailsViewModel MapHotelDetailsToHotelDetailsViewModel(BaseResult <List <HotelView> > hotelView)
{
HotelDetailsViewModel hotel = new HotelDetailsViewModel();
foreach (var item in hotelView.Result)
{
if (!(hotel.HotelId == item.HotelId))
{
hotel.HotelCode = item.HotelCode;
hotel.Location = item.CityName + ", " + item.CountryName;
hotel.HotelId = item.HotelId;
hotel.IsActive = item.IsActive;
hotel.HotelName = item.HotelName;
hotel.HotelChainId = item.HotelChainId;
hotel.HotelBrandId = item.HotelBrandId;
hotel.HotelTypeId = item.HotelTypeId;
hotel.CountryId = item.CountryId;
hotel.CityId = item.CityId;
hotel.Latitude = item.Latitude;
hotel.Longitude = item.Longitude;
hotel.ShortDescription = item.ShortDescription;
hotel.LongDescription = item.LongDescription;
hotel.Website = item.Website;
hotel.ReservationEmail = item.ReservationEmail;
hotel.ReservationContactNo = item.Telephone;
hotel.Address1 = item.Address1;
hotel.Address2 = item.Address2;
hotel.ZipCode = item.ZipCode;
hotel.IsExtranetAccess = item.IsExtranetAccess;
hotel.IsChannelManagerConnectivity = item.IsChannelManagerConnectivity;
hotel.ChannelManagerId = item.ChannelManagerId;
if (item.ChannelManagerId == 0)
{
hotel.ChannelManagerId = null;
}
;
hotel.StarRatingId = item.StarRatingID;
hotel.MGPoint = item.MGPoint;
DateTime dt;
if (item.CheckInFrom != null)
{
dt = new DateTime() + item.CheckInFrom;
hotel.CheckInFrom = dt.ToString("hh:mm tt");
}
//if (item.CheckInTo != null)
//{
// dt = new DateTime() + (TimeSpan)item.CheckInTo;
// hotel.CheckInTo = dt.ToString("hh:mm tt");
//}
//if (item.CheckOutFrom != null)
//{
// dt = new DateTime() + (TimeSpan)item.CheckOutFrom;
// hotel.CheckOutFrom = dt.ToString("hh:mm tt");
//}
if (item.CheckOutTo != null)
{
dt = new DateTime() + (TimeSpan)item.CheckOutTo;
hotel.CheckOutTo = dt.ToString("hh:mm tt");
}
}
if (!(hotel.ContactDetails.AsEnumerable().Where(id => id.ContactId == item.ContactId).Count() > 0))
{
ContactDetailsViewModel contacts = new ContactDetailsViewModel
{
ContactId = item.ContactId,
IsPrimary = item.IsPrimary,
ContactPerson = item.ContactPerson,
DesignationId = item.DesignationId,
EmailAddress = item.ContactEmailAddress,
ContactNumber = item.ContactNumber
};
hotel.ContactDetails.Add(contacts);
}
if (!(hotel.TaxDetails.AsEnumerable().Where(id => id.TaxTypeId == item.TaxTypeId && id.TaxApplicabilityId == item.TaxApplicabilityId).Count() > 0))
{
HotelTaxRelationViewModel tax = new HotelTaxRelationViewModel
{
TaxTypeId = item.TaxTypeId,
TaxesType = item.TaxesType,
TaxApplicabilityId = item.TaxApplicabilityId,
#pragma warning disable CA1305 // Specify IFormatProvider
Amount = Convert.ToDecimal(item.TaxAmount),
#pragma warning restore CA1305 // Specify IFormatProvider
IsIncludedInRates = item.IsIncludedInRates
};
hotel.TaxDetails.Add(tax);
}
HotelPaymentMethodRelationViewModel payment = new HotelPaymentMethodRelationViewModel()
{
HotelPaymentMethodRelationId = item.HotelPaymentMethodRelationId,
PaymentMethodId = item.PaymentMethodId,
CurrencyId = item.CurrencyId,
RateTypeId = item.RateTypeId
};
hotel.HotelPaymentMethodRelation = payment;
}
return(hotel);
}
