public async Task <BaseResult <List <TemplateClauseLibraryViewModel> > > GetClauseLibraryFields(int templateId, int languageId)
{
BaseResult <List <TemplateClauseLibraryViewModel> > clauses = new BaseResult <List <TemplateClauseLibraryViewModel> >();
DynamicParameters paramCollection = ContractsRequestMapper.CreateTemplateClauseLibraryFieldsRequest(templateId, languageId);
var clauseLibraryFieldList = await iTemplateCaluseLibrary.ExecuteStoredProcedure(Constants.StoredProcedure.GetClauseLibraryFieldsByTemplateId, paramCollection).ConfigureAwait(false);
clauses.Result = ContractTemplateResponseMapper.MapToClauseLibraryFieldsToViewModel(clauseLibraryFieldList.Result);
return(clauses);
}
/// <summary>
/// UpdateTemplateClauseLibraryFields
/// </summary>
/// <param name="requestClauseLibraryFields">requestClauseLibraryFields</param>
/// <param name="userName">user Name</param>
/// <param name="templateId">template Id</param>
/// <returns>Status</returns>
public async Task <BaseResult <bool> > UpdateTemplateClauseLibraryFields(List <TemplateClauseLibraryViewModel> requestClauseLibraryFields, string userName, int templateId)
{
BaseResult <bool> result = new BaseResult <bool>();
foreach (var item in requestClauseLibraryFields)
{
DynamicParameters paramCollection = ContractsRequestMapper.UpdateTemplateClauseLibraryFieldsRequest(item, userName, templateId);
var res = await iTemplateCaluseLibrary.ExecuteStoredProcedure(Constants.StoredProcedure.UpdateClauseLibraryFieldsByTemplateId, paramCollection).ConfigureAwait(false);
if (res.IsError || res.ExceptionMessage != null)
{
result.IsError = res.IsError;
result.ExceptionMessage = res.ExceptionMessage;
return(result);
}
}
return(result);
}
/// <summary>
/// Get The count of amenities for selected template (while creating contract).
/// </summary>
/// <param name="templateId"></param>
/// <param name="languageId"></param>
/// <returns> Count of amenities</returns>
public async Task <BaseResult <int> > GetCountOfAmenitiesForSelectedContract(int contractId, int languageId)
{
var result = new BaseResult <int>();
DynamicParameters paramCollection = ContractsRequestMapper.CreateContractFieldsRequestParams(contractId, languageId, true);
var list = await iContractRoomFieldsLibrary.ExecuteStoredProcedure(Constants.StoredProcedure.GetRoomFieldsByContractId, paramCollection).ConfigureAwait(false);
if (list.IsError == true && list.ExceptionMessage != null)
{
result.IsError = list.IsError;
result.ExceptionMessage = list.ExceptionMessage;
return(result);
}
if (list != null && list.Result.Any())
{
var count = list.Result.Count(a => !a.IsConfigurable || (a.IsSelected && a.IsConfigurable));
result.Result = count;
return(result);
}
return(result);
}
/// <summary>
/// private common method for create contract
/// </summary>
/// <param name="contractRequest"></param>
/// <returns></returns>
private async Task <IActionResult> CreateContract(ContractViewModel contractRequest)
{
BaseResult <long> contractResult = null;
if ((contractRequest.Id ?? default(int)) == default(int))
{
var contractStatusResult = await GetContractStatuses().ConfigureAwait(false);
if (contractStatusResult.IsError && contractStatusResult.ExceptionMessage != null)
{
return(StatusCode(500, contractStatusResult));
}
//get status id for draft must present in DB
contractRequest.StatusID = contractStatusResult.Result.First(x => x.Name.Equals(Constants.ContractStatuses.Draft, StringComparison.OrdinalIgnoreCase)).Id;
var contract = ContractsRequestMapper.MapToContractModel(contractRequest, LoggedInUserName);
contractResult = await this.contracts.CreateContract(contract).ConfigureAwait(false);
if (contractResult.IsError && contractResult.ExceptionMessage != null)
{
return(StatusCode(500, contractResult));
}
contractRequest.Id = (int)contractResult.Result;
}
//else for update
//non zero hotel id check!
var contractHotel = ContractsRequestMapper.MapToContractHotelModel(contractRequest.HotelDetails, LoggedInUserName);
contractHotel.ContractId = contractRequest.Id.Value;
var contractHotelResult = await this.contracts.InsertContractHotel(contractHotel).ConfigureAwait(false);
if (contractHotelResult.IsError && contractHotelResult.ExceptionMessage != null)
{
return(StatusCode(500, contractHotelResult));
}
var contractContacts = ContractsRequestMapper.MapToContractContactModelList
(
contractRequest.HotelDetails.ContactDetails, LoggedInUserName,
contractRequest.Id.Value, contractRequest.HotelDetails.HotelId
);
var contractContactResult = await this.contracts.InsertContractContacts(contractContacts).ConfigureAwait(false);
if (contractContactResult.IsError && contractContactResult.ExceptionMessage != null)
{
return(StatusCode(500, contractContactResult));
}
var contractEmailReservation = ContractsRequestMapper.MapToContractEmailReservationModel(contractRequest.HotelDetails, contractRequest.Id.Value, LoggedInUserName);
contractEmailReservation.ContractId = contractRequest.Id.Value;
var contractEmailReservationResult = await this.contracts.InsertContractEmailReservation(contractEmailReservation).ConfigureAwait(false);
if (contractEmailReservationResult.IsError && contractEmailReservationResult.ExceptionMessage != null)
{
return(StatusCode(500, contractEmailReservationResult));
}
var contractTelephoneReservation = ContractsRequestMapper.MapToContractTelephoneReservationModelList
(
contractRequest.HotelDetails.ReservationContactNo, LoggedInUserName,
contractRequest.Id.Value, contractRequest.HotelDetails.HotelId
);
var contractTelephoneReservationResult = await this.contracts.InsertContractTelephoneReservations(contractTelephoneReservation).ConfigureAwait(false);
if (contractTelephoneReservationResult.IsError && contractTelephoneReservationResult.ExceptionMessage != null)
{
return(StatusCode(500, contractTelephoneReservationResult));
}
return(Ok(contractResult));
}
/// <summary>
/// Insert hotel contract relation
/// </summary>
/// <param name="request"></param>
/// <param name="userName"></param>
/// <returns></returns>
public Task <BaseResult <long> > InsertHotelContractRelation(ContractViewModel request, string userName)
{
var hotelContractRelation = ContractsRequestMapper.MapToHotelContractRelationModel(request, userName);
return(iHotelContractRelation.InsertEntity(hotelContractRelation));
}
/// <summary>
/// create contract
/// </summary>
/// <param name="request"></param>
/// <param name="userName"></param>
/// <returns></returns>
public Task <BaseResult <long> > CreateContract(ContractViewModel request, string userName)
{
var contract = ContractsRequestMapper.MapToContractModel(request, userName);
return(iContract.InsertEntity(contract));
}
