public async Task UpdateVehicleToMfrBodyCodeChangeRequestIdAsync(int vehicleToMfrBodyCodeId, long vehicleToMfrBodyCodeChangeRequestId)
        {
            VehicleToMfrBodyCodeDocument document = new VehicleToMfrBodyCodeDocument
            {
                VehicleToMfrBodyCodeId = vehicleToMfrBodyCodeId.ToString(),
                VehicleToMfrBodyCodeChangeRequestId = vehicleToMfrBodyCodeChangeRequestId,
            };

            await _vehicleToMfrBodyCodeIndexingRepositoryService.UpdateDocumentAsync(document);
        }
Ejemplo n.º 2
0
        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);
        }
        private async Task InsertOrUpdateVehicleToMfrBodyCodeDocuments(List <VehicleToMfrBodyCode> updatedVehicleToMfrBodyCodes, bool isReplace = false)
        {
            if (updatedVehicleToMfrBodyCodes == null)
            {
                return;
            }

            foreach (var updatedVehicleToMfrBodyCode in updatedVehicleToMfrBodyCodes)
            //NOTE: updatedVehicles will contain more than 1 item when processing base vehicle replace
            {
                var vehicletoMfrBodyCodeDocument = new VehicleToMfrBodyCodeDocument
                {
                    VehicleToMfrBodyCodeId              = updatedVehicleToMfrBodyCode.Id.ToString(),
                    MfrBodyCodeChangeRequestId          = isReplace ? -1 : (long?)null,
                    VehicleToMfrBodyCodeChangeRequestId = -1,
                    BaseVehicleId      = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicleId,
                    MfrBodyCodeId      = updatedVehicleToMfrBodyCode.MfrBodyCode.Id,
                    MfrBodyCodeName    = updatedVehicleToMfrBodyCode.MfrBodyCode.Name,
                    MakeId             = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.MakeId,
                    MakeName           = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Make.Name,
                    ModelId            = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.ModelId,
                    ModelName          = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Model.Name,
                    RegionId           = updatedVehicleToMfrBodyCode.Vehicle.RegionId,
                    RegionName         = updatedVehicleToMfrBodyCode.Vehicle.Region.Name,
                    Source             = updatedVehicleToMfrBodyCode.Vehicle.SourceName,
                    SubModelId         = updatedVehicleToMfrBodyCode.Vehicle.SubModelId,
                    SubModelName       = updatedVehicleToMfrBodyCode.Vehicle.SubModel.Name,
                    VehicleId          = updatedVehicleToMfrBodyCode.VehicleId,
                    VehicleTypeGroupId =
                        updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Model.VehicleType.VehicleTypeGroupId,
                    VehicleTypeGroupName =
                        updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Model.VehicleType.VehicleTypeGroup.Name,
                    VehicleTypeId   = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Model.VehicleTypeId,
                    VehicleTypeName = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.Model.VehicleType.Name,
                    YearId          = updatedVehicleToMfrBodyCode.Vehicle.BaseVehicle.YearId,
                };

                await
                this._vehicleToMfrBodyCodeIndexingService.UploadDocumentAsync(vehicletoMfrBodyCodeDocument);
            }
        }
        public async Task RejectChangeRequestIndexerAsync(long changeRequestId)
        {
            var vehicletoMfrBodyCodeRepositoryService =
                _vcdbUnitOfWork.GetRepositoryService <VehicleToMfrBodyCode>() as
                IVcdbSqlServerEfRepositoryService <VehicleToMfrBodyCode>;

            if (vehicletoMfrBodyCodeRepositoryService == null)
            {
                return;
            }

            var updatedVehicleToMfrBodyCodes =
                await
                vehicletoMfrBodyCodeRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId);


            if (updatedVehicleToMfrBodyCodes == null || !updatedVehicleToMfrBodyCodes.Any())
            {
                //Pushkar: need to test this condition
                throw new InvalidOperationException(
                          "Vehicle To Mfr Body Code cannot be updated before the transactional table is updated");
            }

            foreach (var updatedVehicleToMfrBodyCode in updatedVehicleToMfrBodyCodes)
            {
                var vehicletoMfrBodyCodeDocument = new VehicleToMfrBodyCodeDocument
                {
                    VehicleToMfrBodyCodeId = updatedVehicleToMfrBodyCode.Id.ToString(),
                    VehicleToMfrBodyCodeChangeRequestId = -1,
                };

                await
                this._vehicleToMfrBodyCodeIndexingService.UploadDocumentAsync(vehicletoMfrBodyCodeDocument);
            }

            //Required when processing MfrBodyCode REPLACE CR
            await ClearMfrBodyCodeChangeRequestId(changeRequestId);
        }
 public async Task UploadDocumentAsync(VehicleToMfrBodyCodeDocument vehicleToMfrBodyCodeDocument)
 {
     await _vehicleToMfrBodyCodeIndexingRepositoryService.UpdateDocumentAsync(vehicleToMfrBodyCodeDocument);
 }
Ejemplo n.º 6
0
 public async Task <DocumentIndexResult> UpdateDocumentAsync(VehicleToMfrBodyCodeDocument vehicleToMfrBodyCodeDocument)
 {
     return(await UpdateDocumentsAsync(new List <VehicleToMfrBodyCodeDocument> {
         vehicleToMfrBodyCodeDocument
     }));
 }
Ejemplo n.º 7
0
 public Task UploadDocumentAsync(VehicleToMfrBodyCodeDocument vehicleToMfrBodyCodeDocument)
 {
     throw new NotImplementedException();
 }