private async Task <BaseResult <bool> > CreateOrUpdateRoomFacilityFields(ContractTemplateViewModel request)
{
var result = new BaseResult <bool>()
{
Result = true
};
var roomFacilityFieldsToAdd = request.RoomFacilityFields.Where(x => x.ObjectState == ObjectState.Added && x.IsSelected).ToList();
if (roomFacilityFieldsToAdd.Any())
{
var insertRoomFacilityFieldResult = await iTemplate.InsertContractTemplateRoomFacilities(roomFacilityFieldsToAdd, LoggedInUserName, request.Id).ConfigureAwait(false);
if (insertRoomFacilityFieldResult.IsError && insertRoomFacilityFieldResult.ExceptionMessage != null)
{
result.IsError = insertRoomFacilityFieldResult.IsError;
result.ExceptionMessage = insertRoomFacilityFieldResult.ExceptionMessage;
return(result);
}
}
var roomFacilityFieldsToUpdate = request.RoomFacilityFields.Where(x => x.ObjectState == ObjectState.Modified).ToList();
if (roomFacilityFieldsToUpdate.Any())
{
result = await iTemplate.UpdateContractTemplateRoomFields(roomFacilityFieldsToUpdate, LoggedInUserName, request.Id).ConfigureAwait(false);
}
return(result);
}
public async Task TestCreateOrUpdateContractTemplate_update_unchanged()
{
//Arrange
var request = new ContractTemplateViewModel()
{
ObjectState = ExHp.ObjectState.Unchanged
};
//Act
var result = await contractTemplatesController.CreateOrUpdateContractTemplate(request).ConfigureAwait(false);
//Assert
}
public static ContractTemplate MapToContractTemplateModel(ContractTemplateViewModel source, string userName)
{
var destination = AutoMapper.Mapper.Map <ContractTemplateViewModel, ContractTemplate>(source);
destination.CreatedBy = userName;
destination.UpdatedBy = userName;
destination.CreatedDate = DateTime.Now.JakartaOffset();
destination.UpdatedDate = DateTime.Now.JakartaOffset();
destination.IsActive = true;
destination.IsDeleted = false;
return(destination);
}
/// <summary>
/// Update Contract Template
/// </summary>
/// <param name="request">request</param>
/// <param name="userName">userName</param>
/// <returns>Bool Value (Success or not)</returns>
public async Task <BaseResult <bool> > UpdateContractTemplateName(ContractTemplateViewModel request, string userName)
{
var templateRequest = ContractTemplateRequestMapper.MapToContractTemplateModel(request, userName);
var param = new DynamicParameters();
param.Add(Constants.StoredProcedureParameters.TemplateId, templateRequest.Id);
param.Add(Constants.StoredProcedureParameters.Name, templateRequest.Name);
param.Add(Constants.StoredProcedureParameters.UpdatedBy, templateRequest.UpdatedBy);
param.Add(Constants.StoredProcedureParameters.UpdatedDate, templateRequest.UpdatedDate);
param.Add(Constants.StoredProcedureParameters.IsPublished, templateRequest.IsPublished);
return(await iContractTemplateLibrary.ExecuteStoredProcedureInsertUpdate(Constants.StoredProcedure.UpdateContractTemplateName, param).ConfigureAwait(false));
}
public async Task <IActionResult> CreateOrUpdateContractTemplate([FromBody] ContractTemplateViewModel request)
{
if (request == null)
{
return(BadRequest());
}
if (!Enum.IsDefined(typeof(ObjectState), request.ObjectState.Value))
{
//wrong object state
return(BadRequest());
}
return(await CreateOrUpdateContractTemplateInternal(request).ConfigureAwait(false));
}
public async Task TestCreateOrUpdateContractTemplate_create_success()
{
//Arrange
var id = 1;
var request = new ContractTemplateViewModel()
{
ObjectState = ExHp.ObjectState.Added,
Name = "temp1",
Id = 0
};
request.HotelFields.Add(new HotelFieldViewModel()
{
Id = id,
IsSelected = true,
ObjectState = ExHp.ObjectState.Added
});
request.ClauseLibraryFields.Add(new TemplateClauseLibraryViewModel()
{
ClauseLibraryId = id,
IsSelected = true,
ObjectState = ExHp.ObjectState.Added
});
request.HotelFacilityFields.Add(new HotelFacilityGroupViewModel()
{
Id = id,
IsSelected = true,
ObjectState = ExHp.ObjectState.Added
});
request.RoomFields.Add(new RoomFieldViewModel()
{
Id = id,
IsSelected = true,
ObjectState = ExHp.ObjectState.Added
});
iTemplate.Setup(x => x.CreateContractTemplate(It.IsAny <ContractTemplateViewModel>(), It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult <long>()
{
Result = id
}));
iTemplate.Setup(x => x.InsertContractTemplateHotelProperties(It.IsAny <List <HotelFieldViewModel> >(), It.IsAny <string>(), It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult <long>()
{
Result = id
}));
//Act
var result = await contractTemplatesController.CreateOrUpdateContractTemplate(request).ConfigureAwait(false);
//Assert
}
private async Task <BaseResult <long> > CreateOrUpdateTemplate(ContractTemplateViewModel request)
{
if (request.ObjectState.Value == ObjectState.Added)
{
var createContractTemplateResult = await iTemplate.CreateContractTemplate(request, LoggedInUserName).ConfigureAwait(false);
if (createContractTemplateResult.IsError && createContractTemplateResult.ExceptionMessage != null)
{
createContractTemplateResult.IsError = createContractTemplateResult.IsError;
createContractTemplateResult.ExceptionMessage = createContractTemplateResult.ExceptionMessage;
return(createContractTemplateResult);
}
request.Id = (int)createContractTemplateResult.Result;
return(createContractTemplateResult);
}
else if (request.ObjectState.Value == ObjectState.Modified)
{
var result = new BaseResult <long>()
{
Result = request.Id
};
var updateContractTemplateResult = await iTemplate.UpdateContractTemplateName(request, LoggedInUserName).ConfigureAwait(false);
if (updateContractTemplateResult.IsError && updateContractTemplateResult.ExceptionMessage != null)
{
result.IsError = updateContractTemplateResult.IsError;
result.ExceptionMessage = updateContractTemplateResult.ExceptionMessage;
return(result);
}
return(result);
}
else
{
return(new BaseResult <long>()
{
Result = request.Id
});;
}
}
private async Task <BaseResult <long> > InsertContractTemplateFacilities(ContractTemplateViewModel request)
{
return(await iTemplate.InsertContractTemplateHotelFacilities(request.HotelFacilityFields, LoggedInUserName, request.Id).ConfigureAwait(false));
}
/// <summary>
/// Update Template Clause Library Fields
/// </summary>
/// <param name="request">request</param>
/// <returns>Result</returns>
private async Task <BaseResult <bool> > UpdateTemplateClauseLibraryFields(ContractTemplateViewModel request)
{
List <TemplateClauseLibraryViewModel> clauseLibraryToUpdate = request.ClauseLibraryFields.Where(x => x.ObjectState == ObjectState.Modified).ToList();
return(await iTemplate.UpdateTemplateClauseLibraryFields(clauseLibraryToUpdate, LoggedInUserName, request.Id).ConfigureAwait(false));
}
/// <summary>
/// Insert Template Clause Library Fields
/// </summary>
/// <param name="request">request</param>
/// <returns>result</returns>
private async Task <BaseResult <long> > InsertTemplateClauseLibraryFields(ContractTemplateViewModel request)
{
List <TemplateClauseLibraryViewModel> clauseLibraryToAdd = request.ClauseLibraryFields.Where(x => x.ObjectState == ObjectState.Added && x.IsSelected).ToList();
return(await iTemplate.InsertTemplateClauseLibraryFields(clauseLibraryToAdd, LoggedInUserName, request.Id).ConfigureAwait(false));
}
private async Task <IActionResult> CreateOrUpdateContractTemplateInternal(ContractTemplateViewModel request)
{
BaseResult <long> createContractTemplateResult = null;
//
createContractTemplateResult = await CreateOrUpdateTemplate(request).ConfigureAwait(false);
if (createContractTemplateResult.IsError && createContractTemplateResult.ExceptionMessage != null)
{
return(StatusCode(500, createContractTemplateResult));
}
//
if (request.HotelFields.Any(x => !x.IsConfigurable && x.IsSelected))
{
return(BadRequest());
}
var createOrUpdateHotelFieldsResult = await CreateOrUpdateHotelFields(request).ConfigureAwait(false);
if (createOrUpdateHotelFieldsResult.IsError && createOrUpdateHotelFieldsResult.ExceptionMessage != null)
{
return(StatusCode(500, createOrUpdateHotelFieldsResult));
}
//
if (request.RoomFields.Any(x => !x.IsConfigurable && x.IsSelected))
{
return(BadRequest());
}
var createOrUpdateRoomFieldsResult = await CreateOrUpdateRoomFields(request).ConfigureAwait(false);
if (createOrUpdateRoomFieldsResult.IsError && createOrUpdateRoomFieldsResult.ExceptionMessage != null)
{
return(StatusCode(500, createOrUpdateRoomFieldsResult));
}
//
var createOrUpdateHotelFacilityResult = await CreateOrUpdateHotelFacilityFields(request).ConfigureAwait(false);
if (createOrUpdateHotelFacilityResult.IsError && createOrUpdateHotelFacilityResult.ExceptionMessage != null)
{
return(StatusCode(500, createOrUpdateHotelFacilityResult));
}
//
var createOrUpdateRoomFacilityResult = await CreateOrUpdateRoomFacilityFields(request).ConfigureAwait(false);
if (createOrUpdateRoomFacilityResult.IsError && createOrUpdateRoomFacilityResult.ExceptionMessage != null)
{
return(StatusCode(500, createOrUpdateRoomFacilityResult));
}
//
var clauseLibraryToAdd = request.ClauseLibraryFields.Where(x => x.ObjectState == ObjectState.Added && x.IsSelected);
if (clauseLibraryToAdd.Any())
{
var insertClauseLibraryFieldResult = await InsertTemplateClauseLibraryFields(request).ConfigureAwait(false);
}
var clauseLibraryToUpdate = request.ClauseLibraryFields.Where(x => x.ObjectState == ObjectState.Modified);
if (clauseLibraryToUpdate.Any())
{
var UpdateClauseLibraryFieldResult = await UpdateTemplateClauseLibraryFields(request).ConfigureAwait(false);
}
return(Ok(createContractTemplateResult));
}
public Task <BaseResult <long> > CreateContractTemplate(ContractTemplateViewModel contractTemplateViewModel, string userName)
{
var contractTemplate = ContractTemplateRequestMapper.MapToContractTemplateModel(contractTemplateViewModel, userName);
return(iContractTemplateLibrary.InsertEntity(contractTemplate));
}
