/// <summary>
/// Return the hotel chains
/// </summary>
/// <returns></returns>
public async Task <IActionResult> GetHotelChains()
{
BaseResult <List <HotelChainViewModel> > hotelChainResultFromCache = new BaseResult <List <HotelChainViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <HotelChainViewModel> >(Constants.CacheKeys.HotelChainList)
};
if (hotelChainResultFromCache.Result == null || hotelChainResultFromCache.Result.Count == 0)
{
BaseResult <List <HotelChain> > hotelChainResult = await iMasterData.GetHotelChains().ConfigureAwait(false);
if (hotelChainResult.IsError && hotelChainResult.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (hotelChainResult.Result == null || hotelChainResult.Result.Count == 0)
{
return(NoContent()); //204
}
else
{
var hotelChainResultAll = DbMapperMasterdata.MapHotelChains(hotelChainResult);
RedisCacheHelper.Instance.Set <List <HotelChainViewModel> >(Constants.CacheKeys.HotelChainList, hotelChainResultAll.Result);
return(Ok(hotelChainResultAll)); //200
}
}
return(Ok(hotelChainResultFromCache)); //200
}
/// <summary>
/// The save contract hotel.
/// </summary>
/// <param name="contractStaticViewModel">
/// The contract static view model.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
private async Task <BaseResult <ContractHotel> > SaveContractHotel(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var result = new BaseResult <ContractHotel>();
var contractHotelViewModel = new ContractHotelViewModel
{
HotelDetailsViewModel =
contractStaticViewModel
.HotelDetailsViewModel,
ContractId = contractStaticViewModel.ContractId
};
var mappedModel = DbMapperMasterdata.AutomapperContractHotel(contractHotelViewModel.HotelDetailsViewModel, loggedUser);
mappedModel.ContractId = contractStaticViewModel.ContractId;
var u = this.iHotel.GetEntity(mappedModel.HotelId).Result.Result;
mappedModel.NameItemId = u.NameItemId;
mappedModel.ShortDescriptionItemId = u.ShortDescriptionItemId;
var insertResult = await this.iContractHotel.InsertEntity(mappedModel).ConfigureAwait(false);
if (insertResult.IsError && insertResult.ExceptionMessage != null)
{
result.IsError = insertResult.IsError;
result.ExceptionMessage = insertResult.ExceptionMessage;
}
return(result);
}
/// <summary>
/// Updates CancellationClauses
/// </summary>
/// <param name="cancellationPolicyViewModel"></param>
/// <returns></returns>
private async Task <BaseResult <CancellationPolicy> > UpdateCancellationClauses(CancellationPolicyClausesViewModel clauseViewModel)
{
BaseResult <CancellationPolicy> result = new BaseResult <CancellationPolicy>();
result.Result = new CancellationPolicy();
var updateResult = new BaseResult <bool>();
var clauseDb = this.iCancellationPolicyClausesConnectionLibrary.GetListByPredicate(p => p.Id == clauseViewModel.CancellationPolicyClausesId).Result.Result.FirstOrDefault();
if (clauseViewModel.ObjectState == ObjectState.Modified)
{
var updatedModel = DbMapperMasterdata.AutomapperCancellationPolicyClause(clauseViewModel, clauseDb);
////this.ValidatePolicyClause(updatedModel);
updateResult = await iCancellationPolicyClausesConnectionLibrary.UpdateEntityByDapper(updatedModel).ConfigureAwait(false);
}
if (clauseViewModel.ObjectState == ObjectState.Added)
{
return(await CreateCancellationPolicyClauses(clauseViewModel).ConfigureAwait(false));
}
if (updateResult.IsError || updateResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = updateResult.ExceptionMessage;
return(result);
}
if (updateResult.Result == true)
{
result.Result.Id = clauseViewModel.CancellationPolicyId;
}
return(result);
}
/// <summary>
/// Return list of Smoking Policy
/// </summary>
/// <returns>Task<IActionResult></returns>
public async Task <IActionResult> GetSmokingPolicy()
{
BaseResult <List <SmokingPolicyViewModel> > SmokingPolicyResult = new BaseResult <List <SmokingPolicyViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <SmokingPolicyViewModel> >(Helper.Constants.CacheKeys.SmokingPolicyList)
};
if (SmokingPolicyResult.Result == null || !SmokingPolicyResult.Result.Any())
{
BaseResult <List <SmokingPolicy> > smokingPolicy = await iRoom.GetSmokingPolicy().ConfigureAwait(false);
if (smokingPolicy.IsError && smokingPolicy.ExceptionMessage != null)
{
return(StatusCode(500, smokingPolicy));
}
else if (smokingPolicy.Result == null || !smokingPolicy.Result.Any())
{
return(NoContent()); //204
}
else
{
var smokingPolicyVm = DbMapperMasterdata.MapSmokingPolicyList(smokingPolicy); //mapping to SmokingPolicyViewModel
RedisCacheHelper.Instance.Set <List <SmokingPolicyViewModel> >(Helper.Constants.CacheKeys.SmokingPolicyList, smokingPolicyVm.Result);
return(Ok(smokingPolicyVm));
}
}
return(Ok(SmokingPolicyResult));//200
}
public async Task <IActionResult> GetContinents()
{
continentResultFromCache = new BaseResult <List <ContinentViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <ContinentViewModel> >(Constants.CacheKeys.ContinentList)
};
if (continentResultFromCache.Result == null || continentResultFromCache.Result.Count == 0)
{
BaseResult <List <Continent> > continentResult = await iMasterData.GetContinents().ConfigureAwait(false);
if (continentResult.IsError && continentResult.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (continentResult.Result == null || continentResult.Result.Count == 0)
{
return(NoContent()); //204
}
else
{
var continentListVm = DbMapperMasterdata.MapContinent(continentResult);
RedisCacheHelper.Instance.Set <List <ContinentViewModel> >(Constants.CacheKeys.ContinentList, continentListVm.Result);
return(Ok(continentListVm)); //200
}
}
return(Ok(continentResultFromCache)); //200
}
/// <summary>
/// Return list of Beds
/// </summary>
/// <returns>Task<IActionResult></returns>
public async Task <IActionResult> GetBed()
{
BaseResult <List <BedViewModel> > BedResult = new BaseResult <List <BedViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <BedViewModel> >(Helper.Constants.CacheKeys.BedList)
};
if (BedResult.Result == null || !BedResult.Result.Any())
{
BaseResult <List <Bed> > Bed = await iRoom.GetBed().ConfigureAwait(false);
if (Bed.IsError && Bed.ExceptionMessage != null)
{
return(StatusCode(500, Bed));
}
else if (Bed.Result == null || !Bed.Result.Any())
{
return(NoContent()); //204
}
else
{
var bedVm = DbMapperMasterdata.MapBedList(Bed); //mapping to BedViewModel
RedisCacheHelper.Instance.Set <List <BedViewModel> >(Helper.Constants.CacheKeys.BedList, bedVm.Result);
return(Ok(bedVm)); //200
}
}
return(Ok(BedResult));//200
}
/// <summary>
/// Retrun all Occupancy
/// </summary>
/// <returns></returns>
public async Task <BaseResult <List <OccupancyViewModel> > > GetOccupancy()
{
// return await iOccupancyConnectionLibrary.GetListByPredicate(id => id.IsActive == true).ConfigureAwait(false);
var occupancyVm = DbMapperMasterdata.MapOccupancy();
return(occupancyVm);
}
/// <summary>
/// SaveContractHotelTax
/// </summary>
/// <param name="contractStaticViewModel"></param>
/// <param name="loggedUser"></param>
/// <returns>Task<BaseResult<long>></returns>
private async Task <BaseResult <long> > SaveContractHotelTax(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var result = new BaseResult <long>();
var contractHotelTaxList = new List <ContractHotelTaxRelation>();
foreach (var item in contractStaticViewModel.HotelDetailsViewModel.TaxDetails)
{
if (item.ObjectState == ObjectState.Added)
{
var model = new ContractHotelTaxRelation();
var mappedmodel = DbMapperMasterdata.AutomapperContractHotelTaxRelation(item, model, contractStaticViewModel, loggedUser, contractStaticViewModel.ObjectState);
contractHotelTaxList.Add(mappedmodel);
}
if (item.ObjectState == ObjectState.Modified)
{
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.ContractId, contractStaticViewModel.ContractId);
param.Add(Constants.StoredProcedureParameters.HotelId, contractStaticViewModel.HotelDetailsViewModel.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 iContractHotelTaxRelation.ExecuteStoredProcedureDynamicModel(Constants.StoredProcedure.UpdateContractHotelTaxRelation, param).ConfigureAwait(false);
}
}
if (contractHotelTaxList != null && contractHotelTaxList.Count > 0)
{
result = await this.iContractHotelTaxRelation.InsertEntityList(contractHotelTaxList).ConfigureAwait(false);
}
return(result);
}
/// <summary>
/// Return list of Size Measures
/// </summary>
/// <returns>Task<IActionResult></returns>
public async Task <IActionResult> GetSizeMeasure()
{
BaseResult <List <SizeMeasureViewModel> > SizeMeasureResult = new BaseResult <List <SizeMeasureViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <SizeMeasureViewModel> >(Helper.Constants.CacheKeys.SizeMeasureList)
};
if (SizeMeasureResult.Result == null || !SizeMeasureResult.Result.Any())
{
BaseResult <List <SizeMeasure> > sizeMeasure = await iRoom.GetSizeMeasure().ConfigureAwait(false);
if (sizeMeasure.IsError && sizeMeasure.ExceptionMessage != null)
{
return(StatusCode(500, sizeMeasure));
}
else if (sizeMeasure.Result == null || !sizeMeasure.Result.Any())
{
return(NoContent()); //204
}
else
{
var sizeMeasureVm = DbMapperMasterdata.MapSizeMeasureList(sizeMeasure); //mapping to SizeMeasureViewModel
RedisCacheHelper.Instance.Set <List <SizeMeasureViewModel> >(Helper.Constants.CacheKeys.SizeMeasureList, sizeMeasureVm.Result);
return(Ok(sizeMeasureVm)); //200
}
}
return(Ok(SizeMeasureResult));//200
}
/// <summary>
/// Gets Cancellation Policy types from MasterData
/// </summary>
/// <returns>Returns cancellation policy types :- Non </returns>
public async Task <IActionResult> GetCancellationPolicyType()
{
var cancellationPolicyTypeChargesCache = new BaseResult <List <CancellationPolicyTypeViewModel> >()
{
Result = RedisCacheHelper.Instance.Get <List <CancellationPolicyTypeViewModel> >(Constants.CacheKeys.CancellationPolicyTypeList)
};
if (cancellationPolicyTypeChargesCache.Result == null || cancellationPolicyTypeChargesCache.Result.Count == 0)
{
var cancellationPolicyTypeResult = await iPolicies.GetCancellationPolicyType().ConfigureAwait(false);
if (cancellationPolicyTypeResult.IsError && cancellationPolicyTypeResult.ExceptionMessage != null)
{
return(StatusCode(500, cancellationPolicyTypeResult));
}
else if (cancellationPolicyTypeResult.Result == null || cancellationPolicyTypeResult.Result.Count == 0)
{
return(this.NoContent()); // 204
}
else
{
var chargesListVm = DbMapperMasterdata.MapCancellationPolicyType(cancellationPolicyTypeResult);
RedisCacheHelper.Instance.Set <List <CancellationPolicyTypeViewModel> >(Constants.CacheKeys.CancellationPolicyTypeList, chargesListVm.Result);
return(this.Ok(chargesListVm)); // 200
}
}
return(this.Ok(cancellationPolicyTypeChargesCache));
}
/// <summary>
/// Get star ratings master data
/// </summary>
/// <returns>Star rating master data</returns>
public async Task <IActionResult> GetStarRating()
{
BaseResult <List <StarRatingViewModel> > starRatingResultFromCache = new BaseResult <List <StarRatingViewModel> >
{
Result = RedisCacheHelper.Instance.Get <List <StarRatingViewModel> >(Constants.CacheKeys.StarRatingList)
};
if (starRatingResultFromCache.Result == null || starRatingResultFromCache.Result.Count == 0)
{
BaseResult <List <StarRating> > starRatingResult = await iMasterData.GetStarRating().ConfigureAwait(false);
if (starRatingResult.IsError && starRatingResult.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (starRatingResult.Result == null || starRatingResult.Result.Count == 0)
{
return(NoContent());
}
else
{
var result = DbMapperMasterdata.MapStarRating(starRatingResult);
RedisCacheHelper.Instance.Set <List <StarRatingViewModel> >(Constants.CacheKeys.StarRatingList, result.Result);
return(Ok(result));
}
}
return(Ok(starRatingResultFromCache));
}
/// <summary>
/// SaveContractContact
/// </summary>
/// <param name="contractStaticViewModel"></param>
/// <param name="loggedUser"></param>
/// <returns>Task<BaseResult<long>></returns>
private async Task <BaseResult <long> > SaveContractContact(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var insertList = new List <ContractContact>();
var updateList = new List <ContractContact>();
var result = new BaseResult <long>();
foreach (var item in contractStaticViewModel.HotelDetailsViewModel.ContactDetails)
{
if (item.ObjectState == ObjectState.Added)
{
item.HotelId = contractStaticViewModel.HotelDetailsViewModel.HotelId;
var contractContactViewModel = DbMapperMasterdata.AutomapperContractContactViewModel(item);
var contractContactModel = DbMapperMasterdata.AutomapperContractContact(contractContactViewModel, loggedUser);
contractContactModel.ContractId = contractStaticViewModel.ContractId;
insertList.Add(contractContactModel);
}
if (item.ObjectState == ObjectState.Modified)
{
item.HotelId = contractStaticViewModel.HotelDetailsViewModel.HotelId;
var contractContactViewModel = DbMapperMasterdata.AutomapperContractContactViewModel(item);
var contractContactModel = DbMapperMasterdata.AutomapperContractContact(contractContactViewModel, loggedUser);
contractContactModel.ContractId = contractStaticViewModel.ContractId;
updateList.Add(contractContactModel);
}
}
if (insertList.Count > 0)
{
result = await iContractContact.InsertEntityList(insertList).ConfigureAwait(false);
if (result != null && result.Result > 0)
{
result.Result = contractStaticViewModel.ContractId;
}
else
{
result.IsError = true;
}
}
if (updateList.Count > 0)
{
var updateResult = await iContractContact.UpdateEntityList(updateList).ConfigureAwait(false);
if (updateResult.Result)
{
result.Result = contractStaticViewModel.ContractId;
}
else
{
result.IsError = true;
}
}
return(result);
}
/// <summary>
/// Updates Cancellation Policy
/// </summary>
/// <param name="cancellationPolicyViewModel"></param>
/// <returns>updated cancellation policy id</returns>
private async Task <BaseResult <CancellationPolicy> > UpdateCancellationPolicy(CancellationPolicyViewModel cancellationPolicyViewModel)
{
var result = new BaseResult <CancellationPolicy>();
result.Result = new CancellationPolicy();
if (cancellationPolicyViewModel.ObjectState == ObjectState.Modified)
{
var cancellationPolicyDbList = await this.iCancellationPolicyConnectionLibrary.GetListByPredicate(p => p.HotelId == cancellationPolicyViewModel.HotelId && p.IsDeleted == false).ConfigureAwait(false);
var cancellationPolicyDb = cancellationPolicyDbList.Result.FirstOrDefault(p => p.Id == cancellationPolicyViewModel.CancellationPolicyId);
if (cancellationPolicyDb != null)
{
var cancellationPolicy =
DbMapperMasterdata.AutomapperCancellationPolicy(cancellationPolicyViewModel,
cancellationPolicyDb);
if (cancellationPolicy.CancellationPolicyTypeId != cancellationPolicyDb.CancellationPolicyTypeId &&
cancellationPolicyDb.CancellationPolicyTypeId == 2)
{
var clausesList = await iCancellationPolicyClausesConnectionLibrary
.GetListByPredicate(p =>
p.CancellationPolicyId == cancellationPolicyDb.Id && p.IsDeleted == false)
.ConfigureAwait(false);
foreach (var item in clausesList.Result)
{
item.IsDeleted = true;
}
await iCancellationPolicyClausesConnectionLibrary.UpdateEntityList(clausesList.Result)
.ConfigureAwait(false);
}
var updateResult = await iCancellationPolicyConnectionLibrary.UpdateEntityByDapper(cancellationPolicy).ConfigureAwait(false);
if (updateResult.IsError || updateResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = updateResult.ExceptionMessage;
return(result);
}
if (updateResult == null)
{
result = null;
}
return(result);
}
else
{
return(result);
}
}
else
{
return(result);
}
}
public async Task <IActionResult> GetAllHotels()
{
BaseResult <List <HotelBrandExtendedViewModel> > result;
var hotelsData = await iHotel.GetAllHotels(LoggedInUserId, LanguageId).ConfigureAwait(false);
if (hotelsData.IsError && hotelsData.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (hotelsData.Result == null || !hotelsData.Result.Any())
{
return(NoContent()); //204
}
result = DbMapperMasterdata.MapToHotelBrandExtendeViewModel(hotelsData);
return(Ok(result));
}
public async Task <IActionResult> GetProfileCompleteness([FromBody][Required] int?HotelId)
{
BaseResult <ProfileCompletenessViewModel> result = new BaseResult <ProfileCompletenessViewModel>();
var profileCompletenessViewModel = new ProfileCompletenessViewModel();
var profileCompletenessData = await iHotel.GetProfileCompleteness(HotelId.Value).ConfigureAwait(false);
if (profileCompletenessData.IsError && profileCompletenessData.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (profileCompletenessData.Result == null || !profileCompletenessData.Result.Any())
{
return(NoContent()); //204
}
DbMapperMasterdata.FillProfileCompletenessViewModel(profileCompletenessViewModel, profileCompletenessData);
result.Result = profileCompletenessViewModel;
return(Ok(result));
}
private async Task <BaseResult <long> > SaveContractHotelTax(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var result = new BaseResult <long>();
var contractHotelTaxList = new List <ContractHotelTaxRelation>();
foreach (var item in contractStaticViewModel.HotelDetailsViewModel.TaxDetails)
{
var mappedViewModel = AutoMapper.Mapper.Map <ContractHotelTaxRelationViewModel>(item);
var mappedmodel = DbMapperMasterdata.AutomapperContractHotelTaxRelation(mappedViewModel, loggedUser);
mappedmodel.HotelId = contractStaticViewModel.HotelDetailsViewModel.HotelId;
mappedmodel.ContractId = contractStaticViewModel.ContractId;
contractHotelTaxList.Add(mappedmodel);
result = await this.iContractHotelTaxRelation.InsertEntity(mappedmodel).ConfigureAwait(false);
}
//var result = await this.iContractHotelTaxRelation.InsertEntityList(contractHotelTaxList).ConfigureAwait(false);
return(result);
}
public async Task <IActionResult> GetAllHotelNames()
{
BaseResult <List <HotelNameViewModel> > hotelNameResult = new BaseResult <List <HotelNameViewModel> >();
BaseResult <List <HotelView> > hotelResult = await iHotel.GetHotels().ConfigureAwait(false);
if (hotelResult.IsError && hotelResult.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (hotelResult.Result == null || hotelResult.Result.Count == 0)
{
return(NoContent()); //204
}
else
{
hotelNameResult = DbMapperMasterdata.MapHotels(hotelResult);
return(Ok(hotelNameResult)); //200
}
}
private async Task <BaseResult <long> > SaveContractContact(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var contractContactList = new List <ContractContact>();
foreach (var item in contractStaticViewModel.HotelDetailsViewModel.ContactDetails)
{
if (item.ObjectState == ObjectState.Added)
{
item.HotelId = contractStaticViewModel.HotelDetailsViewModel.HotelId;
var contractContactViewModel = DbMapperMasterdata.AutomapperContractContactViewModel(item);
var contractContactModel = DbMapperMasterdata.AutomapperContractContact(contractContactViewModel, loggedUser);
contractContactModel.Contractid = contractStaticViewModel.ContractId;
contractContactList.Add(contractContactModel);
}
}
var result = await iContractContact.InsertEntityList(contractContactList).ConfigureAwait(false);
return(result);
}
/// <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>
/// Return the List of Cities
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> GetCities(int id)
{
BaseResult <List <CityViewModel> > cityResult = new BaseResult <List <CityViewModel> >();
if (id < 1)
{
cityResult.Message = Constants.BadRequestErrorMessage.InvalidCountyRequest;
return(BadRequest(cityResult));
}
var cacheData = RedisCacheHelper.Instance.Get <List <CityViewModel> >(Constants.CacheKeys.CityList);
if (cacheData != null && cacheData.Any())
{
cityResult.Result = cacheData;
}
else
{
BaseResult <List <City> > cityResultData = await iMasterData.GetCities().ConfigureAwait(false);
if (cityResultData.IsError && cityResultData.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (cityResultData.Result == null || cityResultData.Result.Count == 0)
{
return(NoContent()); //204
}
else
{ // mapping model to viewmodel
List <CityViewModel> cityListAll = DbMapperMasterdata.MapAllCity(cityResultData);
cityResult.Result = cityListAll;
RedisCacheHelper.Instance.Set <List <CityViewModel> >(Constants.CacheKeys.CityList, cityListAll, false);
}
}
cityResult.Result = cityResult.Result.Where(p => p.CountryId == id).ToList();
return(Ok(cityResult)); //200
}
/// <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);
}
/// <summary>
/// Create Cancellation Policy
/// </summary>
/// <param name="cancellationPolicyViewModel"></param>
/// <returns>returns the Id of the newly created cancellation policy</returns>
private async Task <BaseResult <CancellationPolicy> > CreateCancellationPolicy(CancellationPolicyViewModel cancellationPolicyViewModel)
{
var result = new BaseResult <CancellationPolicy>();
result.Result = new CancellationPolicy();
var policy = DbMapperMasterdata.AutomapperCancellationPolicy(cancellationPolicyViewModel);
var insertResult = await this.iCancellationPolicyConnectionLibrary.InsertEntity(policy).ConfigureAwait(false);
if (insertResult.IsError || insertResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = insertResult.ExceptionMessage;
return(result);
}
if (insertResult == null)
{
result = null;
}
result.Result.Id = (int)insertResult.Result;
return(result);
}
/// <summary>
/// The create contract.
/// </summary>
/// <param name="contractStaticViewModel">
/// The contract view model.
/// </param>
/// <param name="loggedUser">Logged in user name</param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <BaseResult <ContractViewModel> > CreateContract(
ContractStaticViewModel contractStaticViewModel,
string loggedUser)
{
var result = new BaseResult <ContractViewModel>();
var contract = new Contract();
contract = DbMapperMasterdata.AutomapperContract(contractStaticViewModel, contract, loggedUser);
contract.StatusID = 1;
var insertResult = await this.iContract.InsertEntity(contract).ConfigureAwait(false);
contractStaticViewModel.ContractId = (int)insertResult.Result;
var insertResultHotelFields = await this.InsertTemplateFieldsToContractFieldsHotel(contractStaticViewModel)
.ConfigureAwait(false);
var insertResultRoomFields = await this.InsertTemplateFieldsToContractFieldsRoom(contractStaticViewModel)
.ConfigureAwait(false);
await this.SaveContractHotel(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractContact(contractStaticViewModel, loggedUser).ConfigureAwait(false);
//await this.SaveContractHotelTax(contractStaticViewModel, loggedUser).ConfigureAwait(false);
if (insertResult.IsError && insertResult.ExceptionMessage != null)
{
result.IsError = insertResult.IsError;
result.ExceptionMessage = insertResult.ExceptionMessage;
}
result.Result.Id = (int)insertResult.Result;
return(result);
}
/// <summary>
/// Return the hotel brands
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> GetHotelBrands(int id)
{
BaseResult <List <HotelBrandViewModel> > hotelBrandResult = new BaseResult <List <HotelBrandViewModel> >();
if (id < 1)
{
hotelBrandResult.Message = Constants.BadRequestErrorMessage.InvalidChainRequest;
return(BadRequest(hotelBrandResult));
}
var cacheData = RedisCacheHelper.Instance.Get <List <HotelBrandViewModel> >(Constants.CacheKeys.HotelBrandList);
if (cacheData != null && cacheData.Any())
{
hotelBrandResult.Result = cacheData;
}
else
{
BaseResult <List <HotelBrand> > HotelBrandResultData = await iMasterData.GetHotelBrands().ConfigureAwait(false);
if (HotelBrandResultData.IsError && HotelBrandResultData.ExceptionMessage != null)
{
return(new StatusCodeResult(500));
}
else if (HotelBrandResultData.Result == null || HotelBrandResultData.Result.Count == 0)
{
return(NoContent()); //204
}
else
{ // mapping model to viewmodel
List <HotelBrandViewModel> hotelBrandListAll = DbMapperMasterdata.MapAllHotelBrands(HotelBrandResultData);
hotelBrandResult.Result = hotelBrandListAll;
RedisCacheHelper.Instance.Set <List <HotelBrandViewModel> >(Constants.CacheKeys.HotelBrandList, hotelBrandListAll, false);
}
}
hotelBrandResult.Result = hotelBrandResult.Result.Where(p => p.HotelChainId == id).ToList();
return(Ok(hotelBrandResult)); //200
}
/// <summary>
/// Create CancellationPolicyClauses
/// </summary>
/// <param name="clauseViewModel"></param>
/// <returns>returns the cancellation policy clauses id</returns>
private async Task <BaseResult <CancellationPolicy> > CreateCancellationPolicyClauses(CancellationClauseViewModel clauseViewModel, string loggedUser)
{
var result = new BaseResult <CancellationPolicy> {
Result = new CancellationPolicy()
};
var clauseModel = DbMapperMasterdata.AutomapperCancellationPolicyClause(clauseViewModel, null, loggedUser);
clauseModel.CancellationPolicyId = clauseViewModel.CancellationPolicyId;
clauseModel.IsDeleted = false;
////this.ValidatePolicyClause(cancellationPolicyClauses);
var insertResult = await this.iCancellationPolicyClausesConnectionLibrary.InsertEntity(clauseModel).ConfigureAwait(false);
if (insertResult.IsError || insertResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = insertResult.ExceptionMessage;
return(result);
}
result.Result.Id = (int)insertResult.Result;
return(result);
}
/// <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>
/// SaveContractHotel
/// </summary>
/// <param name="contractStaticViewModel"/>
/// <param name="loggedUser"></param>
/// <returns>Task<BaseResult<ContractHotel>></returns>
private async Task <BaseResult <ContractHotel> > SaveContractHotel(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var result = new BaseResult <ContractHotel>()
{
Result = new ContractHotel()
};
var hotel = this.iHotel.GetEntity(contractStaticViewModel.HotelDetailsViewModel.HotelId).Result.Result;
if (contractStaticViewModel.HotelDetailsViewModel.ObjectState == ObjectState.Added)
{
var model = new ContractHotel();
var mappedModel = DbMapperMasterdata.AutomapperContractHotel(contractStaticViewModel, model, hotel, loggedUser, contractStaticViewModel.HotelDetailsViewModel.ObjectState);
await this.SaveContractEmailReservation(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractTelephoneReservation(contractStaticViewModel, loggedUser).ConfigureAwait(false);
var insertResult = await this.iContractHotel.InsertEntity(mappedModel).ConfigureAwait(false);
if (insertResult.IsError && insertResult.ExceptionMessage != null)
{
result.IsError = insertResult.IsError;
result.ExceptionMessage = insertResult.ExceptionMessage;
}
else if (insertResult == null)
{
result = null;
return(result);
}
result.Result.Id = (int)insertResult.Result;
}
if (contractStaticViewModel.HotelDetailsViewModel.ObjectState == ObjectState.Modified)
{
var model1 = await this.iContractHotel.GetEntity(contractStaticViewModel.ContractId).ConfigureAwait(false);
var model = await iContractHotel.GetListByPredicate(p => p.HotelId == contractStaticViewModel.HotelDetailsViewModel.HotelId && p.ContractId == contractStaticViewModel.ContractId).ConfigureAwait(false);
var mappedModel = DbMapperMasterdata.AutomapperContractHotel(contractStaticViewModel, model.Result[0], hotel, loggedUser, contractStaticViewModel.HotelDetailsViewModel.ObjectState);
var updateResult = await this.iContractHotel.UpdateEntityByDapper(mappedModel).ConfigureAwait(false);
await this.SaveContractEmailReservation(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractTelephoneReservation(contractStaticViewModel, loggedUser).ConfigureAwait(false);
if (updateResult.IsError && updateResult.ExceptionMessage != null)
{
result.IsError = updateResult.IsError;
result.ExceptionMessage = updateResult.ExceptionMessage;
}
else if (updateResult == null)
{
result = null;
return(result);
}
if (updateResult.Result == true)
{
result.Result.ContractId = contractStaticViewModel.ContractId;
}
}
return(result);
}
/// <summary>
/// CreateContract
/// </summary>
/// <param name="contractStaticViewModel"></param>
/// <param name="loggedUser"></param>
/// <returns>Task<BaseResult<ContractStaticViewModel>></returns>
public async Task <BaseResult <ContractStaticViewModel> > CreateContract(ContractStaticViewModel contractStaticViewModel, string loggedUser)
{
var result = new BaseResult <ContractStaticViewModel>()
{
Result = new ContractStaticViewModel()
};
var insertResult = new BaseResult <long>();
var updateResult = new BaseResult <bool>();
var contract = this.iContract.GetEntity(id: contractStaticViewModel.ContractId).Result.Result;
result.Result.Id = contractStaticViewModel.ContractId;
contract = DbMapperMasterdata.AutomapperContract(contractStaticViewModel, contract, loggedUser, contractStaticViewModel.ObjectState);
if (contractStaticViewModel.ObjectState == ObjectState.Added)
{
contract.StatusID = 1; /// draft
insertResult = await this.iContract.InsertEntity(contract).ConfigureAwait(false);
contractStaticViewModel.ContractId = (int)insertResult.Result;
result.Result.Id = (int)insertResult.Result;
}
if (contractStaticViewModel.ObjectState == ObjectState.Modified)
{
var contractModified = AutoMapper.Mapper.Map <Contract>(contractStaticViewModel);
updateResult = await iContract.UpdateEntityByDapper(contractModified).ConfigureAwait(false);
result.Result.Id = contractStaticViewModel.ContractId;
}
var insertResultHotelFields = await
this.InsertTemplateFieldsToContractFieldsHotel(contractStaticViewModel, loggedUser).ConfigureAwait(false);
var insertResultRoomFields = await
this.InsertTemplateFieldsToContractFieldsRoom(contractStaticViewModel, loggedUser).ConfigureAwait(false);
var insertContractClausesLibraryRelation = await
this.InsertTemplateClausesToContractClausesLibrary(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractHotel(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractContact(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractHotelTax(contractStaticViewModel, loggedUser).ConfigureAwait(false);
await this.SaveContractPaymentMethod(contractStaticViewModel).ConfigureAwait(false);
if (contractStaticViewModel.ObjectState == ObjectState.Added && insertResult.IsError && insertResult.ExceptionMessage != null)
{
result.IsError = insertResult.IsError;
result.ExceptionMessage = insertResult.ExceptionMessage;
result.Result.Id = (int)insertResult.Result;
return(result);
}
if (contractStaticViewModel.ObjectState == ObjectState.Modified && updateResult.IsError && updateResult.ExceptionMessage != null)
{
result.IsError = updateResult.IsError;
result.ExceptionMessage = updateResult.ExceptionMessage;
result.Result.Id = contractStaticViewModel.ContractId;
return(result);
}
return(result);
}
