public async Task CreateVehicle_NewVehicleRequest_ReturnStatusCodeOK()
{
// Arrange
var vehicleId = 2;
var vehicleRequest = new VehicleRequest
{
VehicleId = vehicleId,
Number = "A-002",
Model = "Honda Civic",
Description = "Red Color"
};
var vehicleResponse = new VehicleResponse
{
Id = Guid.NewGuid(),
VehicleId = vehicleId,
Number = "A-002",
Model = "Honda Civic",
Description = "Red Color"
};
vehiclesService.VehicleExistsAsync(Arg.Any <int>()).Returns(false);
vehiclesService.AddVehicleAsync(Arg.Any <VehicleRequest>()).Returns(Task.FromResult(vehicleResponse));
vehiclesService.GetVehicleAsync(vehicleId).Returns(Task.FromResult(vehicleResponse));
// Act
var actionResult = await vehiclesController.CreateVehicle(vehicleRequest);
// Assert
var requestResult = Assert.IsType <OkObjectResult>(actionResult);
Assert.Equal((int)System.Net.HttpStatusCode.OK, requestResult.StatusCode);
}
private async void Submitt_Clicked(object sender, EventArgs e)
{
actIndicator2.IsRunning = true;
// Check network status
if (NetworkCheck.IsInternet())
{
client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
// var authHeader = new AuthenticationHeaderValue("bearer", "accessToken.Token"); // pass token
// client.DefaultRequestHeaders.Authorization = authHeader;
var enteredValues = orderNumber.Text;
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("ordernum", enteredValues),
});
try {
var result = await client.PostAsync("http://172.16.204.41:7000/getVehicle", formContent);
//var result = await client.PostAsync("https://172.16.204.41:20300/api/vehicle/vindecode/2T1BR32EX6C593681", formContent);
var responseResult = await result.Content.ReadAsStringAsync();
VehicleResponse vehicleResponse = JsonConvert.DeserializeObject <VehicleResponse>(responseResult);
// on error throw a exception
result.EnsureSuccessStatusCode();
if (result.IsSuccessStatusCode)
{
actIndicator2.IsRunning = false;
stackDisplay.SetValue(IsVisibleProperty, true);
VehicleName.Text = vehicleResponse.name;
stackForm.SetValue(IsVisibleProperty, false);
StackVinDisplay.SetValue(IsVisibleProperty, false);
stackVinDisplay.SetValue(IsVisibleProperty, true);
CarNumberDisplace.Text = "Work Order # " + enteredValues;
}
else
{
actIndicator2.IsRunning = false;
await DisplayAlert("Network Problem", "Please check interent connection or server runing status", "OK");
}
}
catch (Exception ex)
{
Debug.WriteLine(" Exception error Order number API ", ex.ToString());
}
}
else
{
actIndicator2.IsRunning = false;
await DisplayAlert("Network Problem", "Please check interent connection or server runing status", "OK");
}
}
public async Task GetVehicle_ByVehicleId_ReturnStatusCodeOK()
{
// Arrange
var vehicleId = 1;
var vehicleResponse = new VehicleResponse
{
Id = Guid.NewGuid(),
VehicleId = 1,
Number = "A-001",
Model = "Honda City",
Description = "Blue Color"
};
vehiclesService.GetVehicleAsync(vehicleId).Returns(Task.FromResult(vehicleResponse));
// Act
var actionResult = await vehiclesController.GetVehicleById(vehicleId);
var objectResult = actionResult as OkObjectResult;
// Assert
var response = objectResult.Value as VehicleResponse;
Assert.NotNull(objectResult);
Assert.Equal(vehicleId, response.VehicleId);
Assert.Equal((int)System.Net.HttpStatusCode.OK, objectResult.StatusCode);
}
// GET api/values/5
public APIResult <VehicleResponse> Get(int id)
{
try
{
using (var ctx = new MainEntities())
{
var data = ctx.Set <DAL.tbl_vehicles>().Find(id);
var car = new VehicleResponse()
{
data = data,
images = new ImagesResponse()
{
Count = ctx.tbl_images.Where(d => d.model_name == "tbl_vehicles" && d.model_id == data.id && d.model_tag == "main").Count(),
Url = (ctx.tbl_images.Where(d => d.model_name == "tbl_vehicles" && d.model_id == data.id && d.model_tag == "main").Count() == 0) ? "" : "/img/scale/tbl_vehicles/" + data.id + "/original/main-{index}.gif"
}
};
if (data == null)
{
return(APIResult <VehicleResponse> .Error(ResponseCode.BackendDatabase, "Error while getting the vehicle data !"));
}
return(APIResult <VehicleResponse> .Success(car, "API_SUCCESS"));
}
}
catch (Exception ex)
{
return(APIResult <VehicleResponse> .Error(ResponseCode.BackendDatabase, ex.Message));
}
}
public async Task <VehicleResponse> GetVehicleByIdAsync(string datasetId, int vehicleId)
{
var response = await _httpclient.GetAsync($"{_baseUrl}/{datasetId}/vehicles/{vehicleId}");
VehicleResponse dto = await response.Content.ReadAsAsync <VehicleResponse>();
return(dto);
}
public async Task <IActionResult> Get(int id)
{
var vehicleResponse = new VehicleResponse();
vehicleResponse.Vehicle = await vehicleRepository.GetVehicleById(id);
if (vehicleResponse.Vehicle is null)
{
vehicleResponse.HttpResponseCode = 404;
}
return(Ok(vehicleResponse));
}
public static async Task <VehicleResponse> GetVehicleDataAsync(string dataSetId, int vehicleId)
{
HttpResponseMessage response = await client.GetAsync(client.BaseAddress.AbsoluteUri + string.Format("/api/{0}/vehicles/{1}", dataSetId, vehicleId));
VehicleResponse vehicleData = null;
if (response.IsSuccessStatusCode)
{
vehicleData = await response.Content.ReadAsAsync <VehicleResponse>();
}
else
{
throw new Exception(string.Format("Unabled to retrieve vehicle information.\n\n{0}", response.ReasonPhrase));
}
return(vehicleData);
}
private async Task CreateVehicleTasksAsync(string datasetId, VehicleIdsResponse responseVehicleIds)
{
List <Task <VehicleResponse> > vTaskList = new List <Task <VehicleResponse> >();
foreach (int id in responseVehicleIds.VehicleIds)
{
Task <VehicleResponse> vResponse = ProcessURLVehicleAsync(datasetId, (int)id);
vTaskList.Add(vResponse);
}
// Await each task.
for (int i = 0; i < vTaskList.Count; i++)
{
VehicleResponse vr = await vTaskList[i];
vehicleList.Add(vr);
}
}
public async Task VehiclesTest(string Token, int ID)
{
var client = new Client();
using (var httpTest = new HttpTest())
{
var moqVehicles = new Vehicle[1];
moqVehicles[0] = new Vehicle {
ID = ID
};
var moqVehicleResponse = new VehicleResponse {
Count = 1, Vehicles = moqVehicles
};
httpTest.RespondWith(200, JsonConvert.SerializeObject(moqVehicleResponse));
var vehicles = await client.Vehicles(new Token { AccessToken = Token });
httpTest.ShouldHaveCalled($"{ServiceURL.BaseURL}/vehicles");
Assert.Equal(vehicles[0].ID, ID);
}
}
/// <summary>
/// Calls Vechicle API to get Vehicle Response
/// </summary>
/// <param name="datasetId">string</param>
/// <param name="iVehicleId">int</param>
/// <returns></returns>
private async Task <VehicleResponse> GetVehicleAsync(string datasetId, int iVehicleId)
{
VehicleResponse vehicleResponse = await vehiclesApi.GetVehicleAsync(datasetId, iVehicleId);
return(vehicleResponse);
}
private async void startButton_Click(object sender, RoutedEventArgs e)
{
resultsTextBox.Clear();
vehicleList.Clear();
dealerList.Clear();
dsInstance = new DataSetApi();
vehicleInstance = new VehiclesApi();
dealerInstance = new DealersApi();
Answer answer = new Answer();
// Get DataSet ID
string datasetId = "";
DatasetIdResponse responseDataSetId = dsInstance.DataSetGetDataSetId();
datasetId = responseDataSetId.DatasetId;
// Get the Dealers and Vehicles for the given DataSetID
// Get VehicleIds
VehicleIdsResponse responseVehicleIds = new VehicleIdsResponse();
responseVehicleIds = vehicleInstance.VehiclesGetIds(datasetId);
//Get Vechicle details for each VehicleId
VehicleResponse responseVehicle = new VehicleResponse();
await CreateVehicleTasksAsync(datasetId, responseVehicleIds);
// For the vehicles, get the dealers
var Ids = vehicleList.Select(v => (int)v.DealerId).ToList().Distinct();
List <int> dealerIds = Ids.ToList();
await CreateDealerTasksAsync(datasetId, dealerIds);
// Once Vehicle list and Dealer list are done, build the answer
List <DealerAnswer> dealerAnswers = new List <DealerAnswer>();
foreach (DealersResponse dealer in dealerList)
{
DealerAnswer dealerAnswer = new DealerAnswer();
dealerAnswer.DealerId = dealer.DealerId;
dealerAnswer.Name = dealer.Name;
List <VehicleAnswer> dealerVehicles = new List <VehicleAnswer>();
List <VehicleResponse> vehicles = vehicleList.Where(v => v.DealerId == dealer.DealerId).ToList();
foreach (VehicleResponse res in vehicles)
{
VehicleAnswer vehicle = new VehicleAnswer();
vehicle.VehicleId = res.VehicleId;
vehicle.Make = res.Make;
vehicle.Model = res.Model;
vehicle.Year = res.Year;
dealerVehicles.Add(vehicle);
}
dealerAnswer.Vehicles = dealerVehicles;
dealerAnswers.Add(dealerAnswer);
}
answer.Dealers = dealerAnswers;
// Post the response answer
AnswerResponse ansResponse = dsInstance.DataSetPostAnswer(datasetId, answer);
string results = ansResponse.Message + "\r\n\r\n" + ansResponse.Success + "\r\n\r\nTime(seconds): " + ansResponse.TotalMilliseconds / 1000.00;
foreach (DealerAnswer d in answer.Dealers)
{
results += "\r\n\r\n----------------------------------------------------------------\r\n\r\n" + d.Name;
results += "\r\n\r\n-------------------------";
foreach (VehicleAnswer v in d.Vehicles)
{
//results += "\r\n\r\n";
results += "\r\n\r\n" + v.Make + " " + v.Model + " " + v.Year;
}
}
resultsTextBox.Text = results;
}
