public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var brakeConfigRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <BrakeConfig>() as
IVcdbSqlServerEfRepositoryService <BrakeConfig>;
if (brakeConfigRepositoryService == null)
{
return;
}
var addedBrakeConfigs =
await
brakeConfigRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId, 100000,
"BrakeABS",
"BrakeSystem",
"FrontBrakeType",
"RearBrakeType");
if (addedBrakeConfigs == null || !addedBrakeConfigs.Any())
{
throw new InvalidOperationException(
"Brake Config Index cannot be updated before the transactional table is updated");
}
var addedBrakeConfig = addedBrakeConfigs.First();
var vehicleToBrakeConfigSearchResult =
await
_vehicletoBrakeConfigSearchService.SearchAsync(null,
$"brakeConfigId eq {addedBrakeConfig.Id}");
var existingVehicleToBrakeConfigDocuments = vehicleToBrakeConfigSearchResult.Documents;
if (existingVehicleToBrakeConfigDocuments != null && existingVehicleToBrakeConfigDocuments.Any())
{
throw new InvalidOperationException(
"BrakeConfig already exisit in VehicleToBrakeConfigIndex. So, this change request cannot be an add request");
}
//brake config is new and therefore not yet available in "vehicletobrakeconfigs" azure search index
VehicleToBrakeConfigDocument newVehicleToBrakeConfigDocument = new VehicleToBrakeConfigDocument
{
VehicleToBrakeConfigId = Guid.NewGuid().ToString(),
BrakeConfigId = addedBrakeConfig.Id,
FrontBrakeTypeId = addedBrakeConfig.FrontBrakeTypeId,
FrontBrakeTypeName = addedBrakeConfig.FrontBrakeType.Name,
RearBrakeTypeId = addedBrakeConfig.RearBrakeTypeId,
RearBrakeTypeName = addedBrakeConfig.RearBrakeType.Name,
BrakeABSId = addedBrakeConfig.BrakeABSId,
BrakeABSName = addedBrakeConfig.BrakeABS.Name,
BrakeSystemId = addedBrakeConfig.BrakeSystemId,
BrakeSystemName = addedBrakeConfig.BrakeSystem.Name,
};
await this._vehicleToBrakeConfigIndexingService.UploadDocumentAsync(newVehicleToBrakeConfigDocument);
}
public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var vehicletoBrakeConfigRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <VehicleToBrakeConfig>() as
IVcdbSqlServerEfRepositoryService <VehicleToBrakeConfig>;
if (vehicletoBrakeConfigRepositoryService == null)
{
return;
}
var addedVehicleToBrakeConfigs =
await
vehicletoBrakeConfigRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId, 100000,
"BrakeConfig.BrakeABS",
"BrakeConfig.BrakeSystem",
"BrakeConfig.FrontBrakeType",
"BrakeConfig.RearBrakeType",
"Vehicle.BaseVehicle.Make",
"Vehicle.BaseVehicle.Model",
"Vehicle.BaseVehicle.Model.VehicleType",
"Vehicle.BaseVehicle.Model.VehicleType.VehicleTypeGroup",
"Vehicle.SubModel",
"Vehicle.Region");
if (addedVehicleToBrakeConfigs == null || !addedVehicleToBrakeConfigs.Any())
{
throw new InvalidOperationException(
"Vehicle To Brake Config Index cannot be updated before the transactional table is updated");
}
//delete document with vehicleToBrakeConfigId of Guid and brakeConfigId of addedVehicleToBrakeConfigs.BrakeConfigId
var vehicleToBrakeConfigSearchResult =
await
_vehicleToBrakeConfigSearchService.SearchAsync(null,
$"brakeConfigId eq {addedVehicleToBrakeConfigs.First().BrakeConfigId}");
var existingVehicleToBrakeConfigDocuments = vehicleToBrakeConfigSearchResult.Documents;
if (existingVehicleToBrakeConfigDocuments != null && existingVehicleToBrakeConfigDocuments.Any())
{
Guid guid;
foreach (var existingVehicleToBrakeConfigDocument in existingVehicleToBrakeConfigDocuments)
{
if (Guid.TryParse(existingVehicleToBrakeConfigDocument.VehicleToBrakeConfigId, out guid))
{
await
this._vehicleToBrakeConfigIndexingService.DeleteDocumentByVehicleToBrakeConfigIdAsync(
existingVehicleToBrakeConfigDocument.VehicleToBrakeConfigId);
}
}
}
await InsertOrUpdateVehicleToBrakeConfigDocuments(addedVehicleToBrakeConfigs);
}
public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var vehicletoWheelBaseRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <VehicleToWheelBase>() as
IVcdbSqlServerEfRepositoryService <VehicleToWheelBase>;
if (vehicletoWheelBaseRepositoryService == null)
{
return;
}
var addedVehicleToWheelBases =
await
vehicletoWheelBaseRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId, 100000,
"WheelBase",
"Vehicle.BaseVehicle.Make",
"Vehicle.BaseVehicle.Model",
"Vehicle.BaseVehicle.Model.VehicleType",
"Vehicle.BaseVehicle.Model.VehicleType.VehicleTypeGroup",
"Vehicle.SubModel",
"Vehicle.Region");
if (addedVehicleToWheelBases == null || !addedVehicleToWheelBases.Any())
{
throw new InvalidOperationException(
"Vehicle To Wheel Base Index cannot be updated before the transactional table is updated");
}
////delete document with vehicleToWheelBaseId of Guid and WheelBaseId of addedVehicleToWheelBases.WheelBaseId
//var vehicleToWheelBaseSearchResult =
// await
// _vehicleToWheelBaseSearchService.SearchAsync(null,
// $"wheelBaseId eq {addedVehicleToWheelBases.First().WheelBaseId}");
//var existingVehicleToWheelBaseDocuments = vehicleToWheelBaseSearchResult.Documents;
//if (existingVehicleToWheelBaseDocuments != null && existingVehicleToWheelBaseDocuments.Any())
//{
// Guid guid;
// foreach (var existingVehicleToWheelBaseDocument in existingVehicleToWheelBaseDocuments)
// {
// if (Guid.TryParse(existingVehicleToWheelBaseDocument.VehicleToWheelBaseId, out guid))
// {
// await
// this._vehicleToWheelBaseIndexingService.DeleteDocumentByVehicleToWheelBaseIdAsync(
// existingVehicleToWheelBaseDocument.VehicleToWheelBaseId);
// }
// }
//}
await InsertOrUpdateVehicleToWheelBaseDocuments(addedVehicleToWheelBases);
}
//Raja: This function logic needs to be revisited
//Pushkar: Revised and unit testing
public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var baseVehicleRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <BaseVehicle>() as
IVcdbSqlServerEfRepositoryService <BaseVehicle>;
if (baseVehicleRepositoryService == null)
{
return;
}
var addedBaseVehicles =
await
baseVehicleRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId, 100000,
"Make",
"Model");
if (addedBaseVehicles == null || !addedBaseVehicles.Any())
{
throw new InvalidOperationException(
"Base Vehicle Index cannot be updated before the transactional table is updated");
}
var addedBaseVehicle = addedBaseVehicles.First();
var vehicleSearchResult =
await
_vehicleSearchService.SearchAsync(null,
$"baseVehicleId eq {addedBaseVehicle.Id}");
var existingVehicleDocuments = vehicleSearchResult?.Documents;
if (existingVehicleDocuments != null && existingVehicleDocuments.Any())
{
throw new InvalidOperationException("Base Vehicle already exist in VehicleIndex. So, this change request cannot be an add request");
}
//base vehicle is new and therefore not yet available in "vehicles" azure search index
var newVehicleDocument = new VehicleDocument
{
VehicleId = Guid.NewGuid().ToString(),
BaseVehicleId = addedBaseVehicle.Id,
MakeId = addedBaseVehicle.MakeId,
MakeName = addedBaseVehicle.Make.Name,
ModelId = addedBaseVehicle.ModelId,
ModelName = addedBaseVehicle.Model.Name,
YearId = addedBaseVehicle.YearId,
};
await this._vehicleIndexingService.UploadDocumentAsync(newVehicleDocument);
}
public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var mfrBodyCodeRepositoryService =
_repositories.GetRepositoryService <MfrBodyCode>() as
IVcdbSqlServerEfRepositoryService <MfrBodyCode>;
if (mfrBodyCodeRepositoryService == null)
{
return;
}
var addedMfrBodyCodes =
await
mfrBodyCodeRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId, 100000
);
if (addedMfrBodyCodes == null || !addedMfrBodyCodes.Any())
{
throw new InvalidOperationException(
"Mfr Body Code Index cannot be updated before the transactional table is updated");
}
var addedMfrBodyCode = addedMfrBodyCodes.First();
var vehicleToMfrBodyCodeSearchResult =
await
_vehicletoMfrBodyCodeSearchService.SearchAsync(null,
$"mfrBodyCodeId eq {addedMfrBodyCode.Id}");
var existingVehicleToMfrBodyCodeDocuments = vehicleToMfrBodyCodeSearchResult.Documents;
if (existingVehicleToMfrBodyCodeDocuments != null && existingVehicleToMfrBodyCodeDocuments.Any())
{
throw new InvalidOperationException(
"Mfr Body Code already exisit in VehicleToMfrBodyCodeIndex. So, this change request cannot be an add request");
}
//MfrBodyCode is new and therefore not yet available in "vehicletoMfrBodyCode" azure search index
VehicleToMfrBodyCodeDocument newMfrBodyCodeConfigDocument = new VehicleToMfrBodyCodeDocument
{
VehicleToMfrBodyCodeId = Guid.NewGuid().ToString(),
MfrBodyCodeId = addedMfrBodyCode.Id,
MfrBodyCodeName = addedMfrBodyCode.Name
};
await this._vehicleToMfrBodyCodeIndexingService.UploadDocumentAsync(newMfrBodyCodeConfigDocument);
}
public async Task AddChangeRequestIndexerAsync(long changeRequestId)
{
var wheelBaseRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <WheelBase>() as
IVcdbSqlServerEfRepositoryService <WheelBase>;
if (wheelBaseRepositoryService == null)
{
return;
}
var addedWheelBases =
await
wheelBaseRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId, 100000
);
if (addedWheelBases == null || !addedWheelBases.Any())
{
throw new InvalidOperationException(
"WheelBase Index cannot be updated before the transactional table is updated");
}
var addedWheelBase = addedWheelBases.First();
var vehicleToWheelBaseSearchResult =
await
_vehicletoWheelBaseSearchService.SearchAsync(null,
$"wheelBaseId eq {addedWheelBase.Id}");
var existingVehicleToWheelBaseDocuments = vehicleToWheelBaseSearchResult.Documents;
if (existingVehicleToWheelBaseDocuments != null && existingVehicleToWheelBaseDocuments.Any())
{
throw new InvalidOperationException(
"WheelBase already exisit in VehicleToWheelBaseIndex. So, this change request cannot be an add request");
}
//WheelBase is new and therefore not yet available in "vehicletoWheelBase" azure search index
VehicleToWheelBaseDocument newVehicleToWheelBaseDocument = new VehicleToWheelBaseDocument
{
VehicleToWheelBaseId = Guid.NewGuid().ToString(),
WheelBaseId = addedWheelBase.Id,
WheelBaseName = addedWheelBase.Base,
WheelBaseMetric = addedWheelBase.WheelBaseMetric,
};
await this._vehicleToWheelBaseIndexingService.UploadDocumentAsync(newVehicleToWheelBaseDocument);
}
public async Task ModifyChangeRequestIndexerAsync(long changeRequestId)
{
var bedLengthRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <BedLength>() as
IVcdbSqlServerEfRepositoryService <BedLength>;
if (bedLengthRepositoryService == null)
{
return;
}
var updatedBedLengths =
await
bedLengthRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId,
100000);
if (updatedBedLengths == null || !updatedBedLengths.Any())
{
throw new InvalidOperationException(
"Bed Length Index cannot be updated before the transactional table is updated");
}
var updatedBrakeAbs = updatedBedLengths.First();
await UpdateVehicleToBedConfigDocuments(updatedBrakeAbs);
}
public VcdbChangeRequestAttachmentBusinessService(IVcdbUnitOfWork vcdbUnitOfWork, ITextSerializer serializer)
: base(vcdbUnitOfWork, serializer)
{
_vcdbUnitOfWork = vcdbUnitOfWork;
_attachmentsStagingRepositoryService = vcdbUnitOfWork.GetRepositoryService <AttachmentsStaging>()
as ISqlServerEfRepositoryService <AttachmentsStaging>;
}
public async Task ModifyChangeRequestIndexerAsync(long changeRequestId)
{
var vehicleTypeRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <VehicleType>() as
IVcdbSqlServerEfRepositoryService <VehicleType>;
if (vehicleTypeRepositoryService == null)
{
return;
}
var updatedVehicleTypes =
await
vehicleTypeRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId);
if (updatedVehicleTypes == null || !updatedVehicleTypes.Any())
{
throw new InvalidOperationException(
"Vehicle Type Index cannot be updated before the transactional table is updated");
}
var updatedVehicleType = updatedVehicleTypes.First();
await UpdateVehicleDocuments(updatedVehicleType);
await UpdateVehicleToBrakeConfigDocuments(updatedVehicleType);
await UpdateVehicleToBedConfigDocuments(updatedVehicleType);
await UpdateVehicleToBodyStyleConfigDocuments(updatedVehicleType);
await UpdateVehicleToWheelBaseDocuments(updatedVehicleType);
await UpdateVehicleToMfrBodyCodeDocuments(updatedVehicleType);
await UpdateVehicleToDriveTypeDocuments(updatedVehicleType);
}
public async Task ModifyChangeRequestIndexerAsync(long changeRequestId)
{
var subModelRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <SubModel>() as
IVcdbSqlServerEfRepositoryService <SubModel>;
if (subModelRepositoryService == null)
{
return;
}
var updatedSubModels =
await
subModelRepositoryService.GetAsync(
item => item.ChangeRequestId == changeRequestId, 100000);
if (updatedSubModels == null || !updatedSubModels.Any())
{
throw new InvalidOperationException(
"Sub Model Index cannot be updated before the transactional table is updated");
}
var updatedSubModel = updatedSubModels.First();
await UpdateVehicleDocuments(updatedSubModel);
await UpdateVehicleToBrakeConfigDocuments(updatedSubModel);
await UpdateVehicleToBedConfigDocuments(updatedSubModel);
await UpdateVehicleToBodyStyleConfigDocuments(updatedSubModel);
}
public VcdbChangeRequestItemBusinessService(IVcdbUnitOfWork repositories, IMapper autoMapper,
ITextSerializer serializer) : base(repositories, autoMapper, serializer)
{
_serializer = serializer;
_changeRequestItemStagingRepositoryService = repositories.GetRepositoryService <ChangeRequestItemStaging>()
as IVcdbSqlServerEfRepositoryService <ChangeRequestItemStaging>;
}
public async Task ModifyChangeRequestIndexerAsync(long changeRequestId)
{
var brakeSystemRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <BrakeSystem>() as
IVcdbSqlServerEfRepositoryService <BrakeSystem>;
if (brakeSystemRepositoryService == null)
{
return;
}
var updatedBrakeSystems =
await
brakeSystemRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId,
100000);
if (updatedBrakeSystems == null || !updatedBrakeSystems.Any())
{
//Pushkar: need to test this condition
throw new InvalidOperationException(
"Brake System Index cannot be updated before the transactional table is updated");
}
var updatedBrakeSystem = updatedBrakeSystems.First();
await UpdateVehicleToBrakeConfigDocuments(updatedBrakeSystem);
}
public VcdbBusinessService(IVcdbUnitOfWork vcdbUnitOfWork,
IVcdbChangeRequestBusinessService vcdbChangeRequestBusinessService,
ITextSerializer serializer)
: base(vcdbUnitOfWork, serializer)
{
_repositoryService = vcdbUnitOfWork.GetRepositoryService <T>() as VcdbSqlServerEfRepositoryService <T>;
ChangeRequestBusinessService = vcdbChangeRequestBusinessService;
}
public VehicleChangeRequestReviewEventHandler(IVcdbUnitOfWork vcdbUnitOfWork,
ITextSerializer serializer,
IVehicleDataIndexer documentIndexer = null)
: base(vcdbUnitOfWork, serializer, documentIndexer)
{
RepositoryService =
vcdbUnitOfWork.GetRepositoryService <Vehicle>() as VcdbSqlServerEfRepositoryService <Vehicle>;
}
public VehicleToWheelBaseBusinessService(IVcdbUnitOfWork vcdbUnitOfWork,
IVcdbChangeRequestBusinessService vcdbChangeRequestBusinessService,
ITextSerializer serializer, IVehicleToWheelBaseIndexingService vehicleToWheelBaseIndexingService = null)
: base(vcdbUnitOfWork, vcdbChangeRequestBusinessService, serializer)
{
_vehicleToWheelBaseRepositoryService = vcdbUnitOfWork.GetRepositoryService <VehicleToWheelBase>() as IVcdbSqlServerEfRepositoryService <VehicleToWheelBase>;
_vcdbChangeRequestBusinessService = vcdbChangeRequestBusinessService;
_vehicleToWheelBaseIndexingService = vehicleToWheelBaseIndexingService;
}
public WheelBaseBusinessService(IVcdbUnitOfWork vcdbUnitOfWork, IVcdbChangeRequestBusinessService vcdbChangeRequestBusinessService,
ITextSerializer serializer, IVehicleToWheelBaseIndexingService vehicleToWheelBaseIndexingService, IVehicleToWheelBaseSearchService vehicleToWheelBaseSearchService)
: base(vcdbUnitOfWork, vcdbChangeRequestBusinessService, serializer)
{
_wheelBaseRepositoryService = vcdbUnitOfWork.GetRepositoryService <WheelBase>() as IVcdbSqlServerEfRepositoryService <WheelBase>;
// todo: needs indexing service
_vehicleToWheelBaseIndexingService = vehicleToWheelBaseIndexingService;
_vehicleToWheelBaseSearchService = vehicleToWheelBaseSearchService;
}
