public async Task <VehicleSearchViewModel> SearchByBaseVehicleId(int baseVehicleId)
{
var applyFilters = new VehicleSearchFilters()
{
BaseVehicleId = baseVehicleId,
};
var result = await _vehicleSearchService.SearchAsync("", applyFilters.ToAzureSearchFilter(),
new SearchOptions
{
FacetsToInclude = new List <string>
{
"regionName",
"vehicleTypeName",
"vehicleTypeGroupName",
"makeName",
"modelName,count:20",
"subModelName,count:20"
},
RecordCount = 1000
});
var vehicleSearchViewModel = _vehicleSearchViewModelMapper.Map(result);
return(vehicleSearchViewModel);
}
//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 vehicleRepositoryService =
_vcdbUnitOfWork.GetRepositoryService <Vehicle>() as IVcdbSqlServerEfRepositoryService <Vehicle>;
if (vehicleRepositoryService == null)
{
return;
}
var addedVehicles =
await vehicleRepositoryService.GetAsync(item => item.ChangeRequestId == changeRequestId, 100000,
"SubModel",
"Region",
"BaseVehicle.Make",
"BaseVehicle.Model",
"BaseVehicle.Model.VehicleType",
"BaseVehicle.Model.VehicleType.VehicleTypeGroup");
if (addedVehicles == null || !addedVehicles.Any())
{
throw new InvalidOperationException(
"Vehicle Index cannot be updated before the transactional table is updated");
}
//delete document with vehicleId of Guid and baseVeicleId of addedVehicles.BaseVehicleId
var vehicleSearchResult =
await
_vehicleSearchService.SearchAsync(null, $"baseVehicleId eq {addedVehicles.First().BaseVehicleId}");
var existingVehicleDocuments = vehicleSearchResult.Documents;
if (existingVehicleDocuments != null && existingVehicleDocuments.Any())
{
Guid guid;
foreach (var existingVehicleDocument in existingVehicleDocuments)
{
if (Guid.TryParse(existingVehicleDocument.VehicleId, out guid))
{
await
this._vehicleIndexingService.DeleteDocumentByVehicleIdAsync(
existingVehicleDocument.VehicleId);
}
}
}
await InsertOrUpdateVehicleDocuments(addedVehicles);
}
private async Task UpdateVehicleDocuments(VehicleType updatedVehicleType)
{
bool isEndReached = false;
int pageNumber = 1;
do
{
var vehicleSearchResult =
await
_vehicleSearchService.SearchAsync(null,
$"vehicleTypeId eq {updatedVehicleType.Id}", new SearchOptions()
{
RecordCount = 1000, PageNumber = pageNumber
});
var existingVehicleDocuments = vehicleSearchResult?.Documents;
if (existingVehicleDocuments != null && existingVehicleDocuments.Any())
{
foreach (var existingVehicleDocument in existingVehicleDocuments)
{
existingVehicleDocument.VehicleTypeName = updatedVehicleType.Name;
}
await
this._vehicleIndexingService.UploadDocumentsAsync(
existingVehicleDocuments.ToList());
pageNumber++;
}
else
{
isEndReached = true;
}
} while (!isEndReached);
}
public override async Task <long> SubmitUpdateChangeRequestAsync <TId>(BaseVehicle entity, TId id, string requestedBy, ChangeType changeType = ChangeType.None,
List <ChangeRequestItemStaging> changeRequestItemStagings = null, CommentsStagingModel comment = null, List <AttachmentsModel> attachments = null, string changeContent = null)
{
if (entity.MakeId.Equals(default(int)) ||
entity.ModelId.Equals(default(int)) ||
entity.YearId == default(int))
{
throw new ArgumentException(nameof(entity));
}
if (id.Equals(default(TId)))
{
throw new ArgumentNullException(nameof(id));
}
if (!entity.Id.Equals(id))
{
throw new ArgumentException("Invalid Base Vehicle Id");
}
var baseVehicleFromDb = await FindAsync(id);
if (baseVehicleFromDb == null)
{
throw new NoRecordFound("No Base Vehicle exist");
}
changeRequestItemStagings = changeRequestItemStagings ?? new List <ChangeRequestItemStaging>();
// validation check on insert of new base vehicle
await ValidateConfigurationDoesNotMatchWithExistingBaseVehicle(entity);
await ValidateNoChangeRequestExistsWithSameConfiguration(entity);
await ValidateBaseVehicleLookupsHasNoChangeRequest(entity);
await ValidateBaseVehicleDependentHasNoChangeRequest(entity);
await ValidateBaseVehicleHasNoReplacementChangeRequest(entity);
entity.InsertDate = baseVehicleFromDb.InsertDate;
// to eliminate circular reference during serialize,
var existingEntity = new BaseVehicle()
{
Id = baseVehicleFromDb.Id,
ChangeRequestId = baseVehicleFromDb.ChangeRequestId,
MakeId = baseVehicleFromDb.MakeId,
ModelId = baseVehicleFromDb.ModelId,
YearId = baseVehicleFromDb.YearId,
VehicleCount = baseVehicleFromDb.VehicleCount,
DeleteDate = baseVehicleFromDb.DeleteDate,
InsertDate = baseVehicleFromDb.InsertDate,
LastUpdateDate = baseVehicleFromDb.LastUpdateDate
};
changeRequestItemStagings.Add(new ChangeRequestItemStaging()
{
ChangeType = ChangeType.Modify,
EntityId = entity.Id.ToString(),
CreatedDateTime = DateTime.UtcNow,
Entity = typeof(BaseVehicle).Name,
Payload = base.Serializer.Serialize(entity),
ExistingPayload = base.Serializer.Serialize(existingEntity) // also add existing record as ExistingPayload
});
changeContent = string.Format("{0} / {1} / {2}"
, baseVehicleFromDb.YearId
, baseVehicleFromDb.Make.Name
, baseVehicleFromDb.Model.Name);
// NOTE: change-request-comments-staging perfomed on base
var changeRequestId = await base.SubmitUpdateChangeRequestAsync(entity, id, requestedBy, ChangeType.Modify, changeRequestItemStagings, comment, attachments, changeContent);
baseVehicleFromDb.ChangeRequestId = changeRequestId;
_baseVehicleRepositoryService.Update(baseVehicleFromDb);
Repositories.SaveChanges();
IList <Vehicle> vehicles = await base.Repositories.GetRepositoryService <Vehicle>()
.GetAsync(item => item.BaseVehicleId == baseVehicleFromDb.Id && item.DeleteDate == null);
if (vehicles == null || vehicles.Count == 0)
{
var vehicleSearchResult = await _vehicleSearchService.SearchAsync(null, $"baseVehicleId eq {baseVehicleFromDb.Id}");
var existingVehicleDocuments = vehicleSearchResult.Documents;
if (existingVehicleDocuments != null && existingVehicleDocuments.Any())
{
foreach (var existingVehicleDocument in existingVehicleDocuments)
{
//existingVehicleDocument.VehicleId must be a GUID string
await _vehicleIndexingService.UpdateBaseVehicleChangeRequestIdAsync(existingVehicleDocument.VehicleId, changeRequestId);
}
}
}
else
{
foreach (var vehicle in baseVehicleFromDb.Vehicles)
{
await _vehicleIndexingService.UpdateBaseVehicleChangeRequestIdAsync(vehicle.Id.ToString(), changeRequestId);
}
}
return(changeRequestId);
}
