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; }