public async Task Should_Get_Parking_Lots_By_Name()
{
// given
var scope = Factory.Services.CreateScope();
var scopedServices = scope.ServiceProvider;
ParkingLotContext context = scopedServices.GetRequiredService <ParkingLotContext>();
// when
int startindex = 1;
int endindex = 2;
ParkingLotDto parkingLotDto1 = new ParkingLotDto()
{
Name = "parkinglot1",
Capacity = 4,
Location = "Beijing",
};
ParkingLotDto parkingLotDto2 = new ParkingLotDto()
{
Name = "parkinglot2",
Capacity = 3,
Location = "Beijing",
};
ParkingLotService parkingLotService = new ParkingLotService(context);
await parkingLotService.AddParkingLot(parkingLotDto1);
await parkingLotService.AddParkingLot(parkingLotDto2);
var parkingLot = await parkingLotService.GetByName("parkinglot2");
Assert.Equal(parkingLotDto2, parkingLot);
}
public async Task Should_delete_specific_parkingLot_when_give_name_Test()
{
var scope = Factory.Services.CreateScope();
var scopeServices = scope.ServiceProvider;
ParkingLotDbContext context = scopeServices.GetRequiredService <ParkingLotDbContext>();
ParkingLotDto parkingLot1 = new ParkingLotDto();
parkingLot1.Name = "345";
parkingLot1.Capacity = 0;
parkingLot1.Location = "southRoad";
ParkingLotDto parkingLot2 = new ParkingLotDto();
parkingLot2.Name = "234";
parkingLot2.Capacity = 0;
parkingLot2.Location = "southRoad";
ParkingLotService parkingLotService = new ParkingLotService(context);
var name1 = await parkingLotService.AddParkingLot(parkingLot1);
var name2 = await parkingLotService.AddParkingLot(parkingLot2);
await parkingLotService.DeleteParkingLot(parkingLot1.Name);
Assert.Equal(1, context.ParkingLots.Count());
}
public async Task Should_Delete_Parkinglot_Success()
{
// Given
var client = GetClient();
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "ParkingLot_A";
parkingLotDto.Capacity = 30;
parkingLotDto.Location = "Beijing";
// When
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var response = await client.PostAsync("/parkingLots", content);
await client.DeleteAsync(response.Headers.Location);
// Then
var allParkingLots = await client.GetAsync("/parkingLots");
var body = await allParkingLots.Content.ReadAsStringAsync();
var parkingLotsReceived = JsonConvert.DeserializeObject <List <ParkingLotDto> >(body);
//Assert.Equal(0, parkingLotsReceived.Count);
Assert.Empty(parkingLotsReceived);
}
public async Task Should_delete_parkingLot_when_delete_parkingLot_by_name()
{
// given
var client = GetClient();
ParkingLotDto parkingLotDto = GenerateParkingLotDto();
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/ParkingLots", content);
var response = await client.GetAsync($"/ParkingLots/{parkingLotDto.Name}");
var responseBody = await response.Content.ReadAsStringAsync();
var responseParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody);
Assert.Equal(parkingLotDto.Name, responseParkingLot.Name);
// when
var deleteResponse = await client.DeleteAsync($"/ParkingLots/{parkingLotDto.Name}");
var getResponse = await client.GetAsync($"/ParkingLots/{parkingLotDto.Name}");
var getResponseBody = await getResponse.Content.ReadAsStringAsync();
var responseParkingLotAfterDelete = JsonConvert.DeserializeObject <ParkingLotDto>(getResponseBody);
// then
Assert.True(deleteResponse.StatusCode == HttpStatusCode.NoContent);
Assert.Null(responseParkingLotAfterDelete.Name);
}
public async Task Should_Return_The_Parking_Lot_IS_Full_Given_Parking_Lot_is_Full()
{
//given
var client = GetClient();
var parkingLot = new ParkingLotDto()
{
Name = "uniqueName", Capacity = 0, Location = "BEIJING"
};
var requestBody = Serialize(parkingLot);
var parkingLotPostResponse = await client.PostAsync("/ParkingLots", requestBody);
var car = new CarOrderDto()
{
PlateNumber = "N95024", ParkingLotName = "uniqueName"
};
var carRequestBody = Serialize(car);
//when
var orderPostResponse = await client.PostAsync($"/Orders", carRequestBody);
//then
Assert.Equal(HttpStatusCode.BadRequest, orderPostResponse.StatusCode);
var response = await orderPostResponse.Content.ReadAsStringAsync();
Assert.Equal("The parking lot is full", response);
}
public async Task Should_return_200_when_click_specific_parkingLot_success()
{
ParkingLotDto parkingLotDto1 = new ParkingLotDto()
{
Name = "NO.1",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
ParkingLotDto parkingLotDto2 = new ParkingLotDto()
{
Name = "NO.2",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
string httpContent1 = JsonConvert.SerializeObject(parkingLotDto1);
string httpContent2 = JsonConvert.SerializeObject(parkingLotDto2);
StringContent content1 = new StringContent(httpContent1, Encoding.UTF8, MediaTypeNames.Application.Json);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/parkinglots", content1);
var responsePost2 = await client.PostAsync("/parkinglots", content2);
var response = await client.GetAsync(responsePost2.Headers.Location);
var body = await response.Content.ReadAsStringAsync();
var returnParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(body);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(parkingLotDto2, returnParkingLot);
}
public async Task Should_return_204_when_delete_parkingLot_success()
{
ParkingLotDto parkingLotDto1 = new ParkingLotDto()
{
Name = "NO.1",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
ParkingLotDto parkingLotDto2 = new ParkingLotDto()
{
Name = "NO.2",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
string httpContent1 = JsonConvert.SerializeObject(parkingLotDto1);
StringContent content1 = new StringContent(httpContent1, Encoding.UTF8, MediaTypeNames.Application.Json);
string httpContent2 = JsonConvert.SerializeObject(parkingLotDto2);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
var responsePost1 = await client.PostAsync("/parkinglots", content1);
var responsePost2 = await client.PostAsync("/parkinglots", content2);
var response1 = await client.DeleteAsync(responsePost1.Headers.Location);
var allParkingLotsResponse = await client.GetAsync("/parkinglots");
var body = await allParkingLotsResponse.Content.ReadAsStringAsync();
var returnParkingLots = JsonConvert.DeserializeObject <List <ParkingLotDto> >(body);
Assert.Equal(HttpStatusCode.NoContent, response1.StatusCode);
Assert.Single(returnParkingLots);
Assert.Equal(parkingLotDto2, returnParkingLots[0]);
Assert.Equal(1, context.ParkingLot.Count());
}
public async Task Should_Update_parkingLot_Capacity_Patch_UpdateParkingLot()
{
// given
ParkingLotDto parkingLotDto = new ParkingLotDto()
{
Name = "NO.1",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
string httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var responsePost = await client.PostAsync("/parkinglots", content);
// when
UpdateParkingLotDto updateParkingLotDto = new UpdateParkingLotDto()
{
Name = "NO.1",
Capacity = 10,
Location = "BeiJingSouthRailWayStationParkingLot"
};
string httpContentPatch = JsonConvert.SerializeObject(updateParkingLotDto);
StringContent contentPatch = new StringContent(httpContentPatch, Encoding.UTF8, MediaTypeNames.Application.Json);
var response = await client.PatchAsync(responsePost.Headers.Location, contentPatch);
var body = await response.Content.ReadAsStringAsync();
var returnParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(body);
// then
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(updateParkingLotDto.Capacity, returnParkingLot.Capacity);
Assert.Equal(1, context.ParkingLot.Count());
}
public ParkingLotEntity(ParkingLotDto parkingLotDto)
{
Name = parkingLotDto.Name;
Capacity = parkingLotDto.Capacity;
Location = parkingLotDto.Location;
AvailablePosition = Capacity;
}
public async Task Should_get_parkingLots_by_page_index_when_get_parkingLots_by_page_index()
{
// given
var client = GetClient();
for (var i = 0; i < 20; i++)
{
ParkingLotDto parkingLotDto = GenerateParkingLotDto();
parkingLotDto.Capacity = i;
parkingLotDto.Location = "AmazingStreetNo." + i;
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/ParkingLots", content);
}
var pageIndex = 1;
// when
var response = await client.GetAsync($"/ParkingLots/pages/{pageIndex}");
var responseBody = await response.Content.ReadAsStringAsync();
var parkingLots = JsonConvert.DeserializeObject <List <ParkingLotDto> >(responseBody);
// then
Assert.Equal(15, parkingLots.Count);
}
public async Task Should_Get_Parkinglot_By_Id_Success()
{
// Given
var client = GetClient();
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "ParkingLot_A";
parkingLotDto.Capacity = 30;
parkingLotDto.Location = "Beijing";
// When
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
// Then
var response = await client.PostAsync("/parkingLots", content);
var allParkingLotsResponse = await client.GetAsync(response.Headers.Location);
var body = await allParkingLotsResponse.Content.ReadAsStringAsync();
var returnParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(body);
Assert.Equal(parkingLotDto.Name, returnParkingLot.Name);
Assert.Equal(parkingLotDto.Capacity, returnParkingLot.Capacity);
Assert.Equal(parkingLotDto.Location, returnParkingLot.Location);
}
public async Task <ActionResult <ParkingLotDto> > Add(ParkingLotDto parkingLotDto)
{
if (string.IsNullOrEmpty(parkingLotDto.Name))
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Input with Name null or empty." }));
}
if (string.IsNullOrEmpty(parkingLotDto.Location))
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Input with No Location null or empty" }));
}
if (parkingLotDto.Capacity == null || parkingLotDto.Capacity < 0)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Input with Capacity null or minus." }));
}
if (parkingLotContext.ParkingLot.Any(parkingLotEntity => parkingLotEntity.Name == parkingLotDto.Name))
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Input parkingLot name is already exist." }));
}
var id = await this.parkingLotService.AddParkingLot(parkingLotDto);
return(CreatedAtAction(nameof(GetById), new { id = id }, parkingLotDto));
}
public async Task Should_update_parkingLot_capacity_successfully()
{
var client = GetClient();
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "LiverpoolLot";
parkingLotDto.Location = "Liverpool";
parkingLotDto.Capacity = 100;
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var postResponse = await client.PostAsync("/parkingLots", content);
UpdateParkingLotDto updateParkingLotDto = new UpdateParkingLotDto();
updateParkingLotDto.Capacity = 300;
var httpContent2 = JsonConvert.SerializeObject(updateParkingLotDto);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PatchAsync(postResponse.Headers.Location, content2);
var updateParkingLotResponse = await client.GetAsync(postResponse.Headers.Location);
var body = await updateParkingLotResponse.Content.ReadAsStringAsync();
var returnUpdateParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(body);
Assert.Equal(300, returnUpdateParkingLot.Capacity);
}
public async Task Should_not_update_parkingLot_capacity_if_it_is_less_than_zero()
{
var client = GetClient();
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "LiverpoolLot";
parkingLotDto.Location = "Liverpool";
parkingLotDto.Capacity = 100;
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var postResponse = await client.PostAsync("/parkingLots", content);
UpdateParkingLotDto updateParkingLotDto = new UpdateParkingLotDto();
updateParkingLotDto.Capacity = -2;
var httpContent2 = JsonConvert.SerializeObject(updateParkingLotDto);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
var patchResponse = await client.PatchAsync(postResponse.Headers.Location, content2);
var updateParkingLotResponse = await client.GetAsync(postResponse.Headers.Location);
var body = await updateParkingLotResponse.Content.ReadAsStringAsync();
var returnUpdateParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(body);
Assert.Equal(100, returnUpdateParkingLot.Capacity);
Assert.Equal(StatusCodes.Status400BadRequest, (int)patchResponse.StatusCode);
}
public async Task Should_return_InnerError_when_create_parkingLot_with_same_name()
{
ParkingLotDto parkingLotDto1 = new ParkingLotDto()
{
Name = "NO.2",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
ParkingLotDto parkingLotDto2 = new ParkingLotDto()
{
Name = "NO.2",
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
string httpContent1 = JsonConvert.SerializeObject(parkingLotDto1);
string httpContent2 = JsonConvert.SerializeObject(parkingLotDto2);
StringContent content1 = new StringContent(httpContent1, Encoding.UTF8, MediaTypeNames.Application.Json);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/parkinglots", content1);
var response = await client.PostAsync("/parkinglots", content2);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Equal(1, context.ParkingLot.Count());
}
public async Task Should_get_parkingLots_on_one_page_according_to_page_size_and_start_page()
{
var client = GetClient();
for (int i = 0; i < 20; i++)
{
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "LiverpoolLot" + $"{i}";
parkingLotDto.Location = "Liverpool";
parkingLotDto.Capacity = 100;
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/parkingLots", content);
}
var allParkingLotResponse = await client.GetAsync("/parkingLots");
var body1 = await allParkingLotResponse.Content.ReadAsStringAsync();
var returnAllParkingLots = JsonConvert.DeserializeObject <List <ParkingLotDto> >(body1);
Assert.Equal(20, returnAllParkingLots.Count);
var parkingLotsOnOnePageResponse = await client.GetAsync("/parkinglots?pagesize=15&startpage=1");
var body = await parkingLotsOnOnePageResponse.Content.ReadAsStringAsync();
var returnParkingLots = JsonConvert.DeserializeObject <List <ParkingLotDto> >(body);
Assert.Equal(15, returnParkingLots.Count);
}
public async Task Should_Return_Error_Message_When_Parking_Lot_Is_Full()
{
// given
var client = GetClient();
var parkingLotDto = new ParkingLotDto()
{
Name = "parkinglot1",
Capacity = 0,
Location = "Beijing",
};
var parkingLotContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent parkingLotcontent = new StringContent(parkingLotContent, Encoding.UTF8, MediaTypeNames.Application.Json);
// when
await client.PostAsync("/parkinglots", parkingLotcontent);
var orderCreateDto = new OrderCreateDto()
{
ParkingLotName = "parkinglot1",
PlateNumber = "abc123",
};
var httpContent = JsonConvert.SerializeObject(orderCreateDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
// when
var postResponse = await client.PostAsync("/orders", content);
var body = await postResponse.Content.ReadAsStringAsync();
// then
Assert.Equal("The parking lot is full", body);
}
public async Task Should_update_parkingLot_when_update()
{
this.client.DeleteAsync("/parkingLots/clear");
//given
var request1 = JsonConvert.SerializeObject(parkingLotDto1);
var request2 = JsonConvert.SerializeObject(parkingLotDto2);
StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
var response1 = await client.PostAsync("/parkingLots", requestBody1);
var response2 = await client.PostAsync("/parkingLots", requestBody2);
var responseBody1 = await response1.Content.ReadAsStringAsync();
ParkingLotDto addParkingLot1 = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody1);
var name = addParkingLot1.Name;
var update = new UpdateParkingLotDto(50);
parkingLotDto1.Capacity = update.Capacity;
var updateRequest = JsonConvert.SerializeObject(update);
StringContent updateRequestBody = new StringContent(updateRequest, Encoding.UTF8, "application/json");
//when
var response = await client.PatchAsync($"/parkingLots/{name}", updateRequestBody);
var responseBody = await response.Content.ReadAsStringAsync();
ParkingLotDto respondParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody);
//then
var parkingLotDto1String = JsonConvert.SerializeObject(parkingLotDto1);
var respondParkingLotString = JsonConvert.SerializeObject(respondParkingLot);
Assert.Equal(parkingLotDto1String, respondParkingLotString);
}
public async Task Should_update_parkingLot_capacity_when_update_parkingLot_by_name()
{
// given
var client = GetClient();
ParkingLotDto parkingLotDto = GenerateParkingLotDto();
UpdateParkingLotCapacityDto updateParkingLotCapacityDto = new UpdateParkingLotCapacityDto(10);
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/ParkingLots", content);
var response = await client.GetAsync($"/ParkingLots/{parkingLotDto.Name}");
var responseBody = await response.Content.ReadAsStringAsync();
var responseParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody);
Assert.Equal(parkingLotDto.Capacity, responseParkingLot.Capacity);
Assert.NotEqual(updateParkingLotCapacityDto.Capacity, responseParkingLot.Capacity);
var httpPatchContent = JsonConvert.SerializeObject(updateParkingLotCapacityDto);
StringContent patchContent = new StringContent(httpPatchContent, Encoding.UTF8, MediaTypeNames.Application.Json);
// when
var patchResponse = await client.PatchAsync($"/ParkingLots/{parkingLotDto.Name}", patchContent);
var patchResponseBody = await patchResponse.Content.ReadAsStringAsync();
var changedParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(patchResponseBody);
// then
Assert.Equal(updateParkingLotCapacityDto.Capacity, changedParkingLot.Capacity);
}
public async Task Should_Delete_Parking_Lot()
{
// given
var client = GetClient();
var parkingLotDto = new ParkingLotDto()
{
Name = "parkinglot1",
Capacity = 5,
Location = "Beijing",
};
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync("/parkinglots", content);
// when
await client.DeleteAsync("/parkinglots/parkinglot1");
var allCompaniesResponse = await client.GetAsync("/parkinglots");
var body = await allCompaniesResponse.Content.ReadAsStringAsync();
var returnParkingLots = JsonConvert.DeserializeObject <List <ParkingLotDto> >(body);
// then
var expectedParkingLotDtoList = new List <ParkingLotDto>
{
};
Assert.Equal(expectedParkingLotDtoList, returnParkingLots);
}
public async Task Should_Update_Parkinglot_Capacity_Success()
{
// Given
var client = GetClient();
ParkingLotDto parkingLotDto = new ParkingLotDto();
parkingLotDto.Name = "ParkingLot_A";
parkingLotDto.Capacity = 30;
parkingLotDto.Location = "Beijing";
// When
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var response = await client.PostAsync("/parkingLots", content);
var updateParkingLot = new ParkingLotUpdateDto();
updateParkingLot.Capacity = 50;
var updateHttpContent = JsonConvert.SerializeObject(updateParkingLot);
StringContent updateContent = new StringContent(updateHttpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
var allParkingLotsResponse = await client.PatchAsync(response.Headers.Location, updateContent);
// Then
var searchResponse = await client.GetAsync(response.Headers.Location);
var searchBody = await searchResponse.Content.ReadAsStringAsync();
var searchParkingLotDto = JsonConvert.DeserializeObject <ParkingLotDto>(searchBody);
Assert.Equal(updateParkingLot.Capacity, searchParkingLotDto.Capacity);
}
public async Task Should_return_parkingLot_when_get_by_name()
{
var request1 = JsonConvert.SerializeObject(parkingLotDto1);
var request2 = JsonConvert.SerializeObject(parkingLotDto2);
StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
var response1 = await client.PostAsync("/parkingLots", requestBody1);
var response2 = await client.PostAsync("/parkingLots", requestBody2);
var responseBody1 = await response1.Content.ReadAsStringAsync();
ParkingLotDto addParkingLot1 = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody1);
var parkingLotName = addParkingLot1.Name;
var response = await client.GetAsync($"/parkingLots/{parkingLotName}");
var responseBody = await response.Content.ReadAsStringAsync();
ParkingLotDto respondParkingLot = JsonConvert.DeserializeObject <ParkingLotDto>(responseBody);
var parkingLotDto1String = JsonConvert.SerializeObject(parkingLotDto1);
var respondParkingLotString = JsonConvert.SerializeObject(respondParkingLot);
Assert.Equal(parkingLotDto1String, respondParkingLotString);
//Assert.Equal(parkingLotDto, respondParkingLot);
}
public ParkingLotEntity(ParkingLotDto parkingLotDto)
{
this.Name = parkingLotDto.Name;
this.Locatoin = parkingLotDto.Locatoin;
this.Capacity = parkingLotDto.Capacity;
this.Cars = parkingLotDto.Cars.Select(carDto => new CarEntity(carDto)).ToList();
this.Orders = parkingLotDto.Orders.Select(orderDto => new OrderEntity(orderDto)).ToList();
}
public ParkingLotEntity(ParkingLotDto parkingLotDto)
{
Name = parkingLotDto.Name;
Capacity = parkingLotDto.Capacity;
Location = parkingLotDto.Location;
Cars = parkingLotDto.Cars.Select(carDto => new CarEntity(carDto)).ToList();
Orders = parkingLotDto.Orders.Select(orderDto => new OrderEntity(orderDto)).ToList();
}
public async Task <string> AddParkingLot(ParkingLotDto parkingLotDto)
{
ParkingLotEntity parkingLotEntity = new ParkingLotEntity(parkingLotDto);
await parkingLotContext.ParkingLots.AddAsync(parkingLotEntity);
await parkingLotContext.SaveChangesAsync();
return(parkingLotEntity.Name);
}
public async Task <int> AddParkingLot(ParkingLotDto parkingLotDto)
{
ParkingLotEntity parkingLotEntity = new ParkingLotEntity(parkingLotDto);
await this.parkingLotContext.ParkingLot.AddAsync(parkingLotEntity);
await this.parkingLotContext.SaveChangesAsync();
return(parkingLotEntity.Id);
}
private ParkingLotDto GetParkingLotDto(string name)
{
var parkingLotDto = new ParkingLotDto()
{
Name = name,
Capacity = 50,
Location = "BeiJingSouthRailWayStationParkingLot"
};
return(parkingLotDto);
}
public async Task <ActionResult <ParkingLotDto> > AddParkingLot(ParkingLotDto parkingLotDto)
{
int?id = await parkingLotService.AddParkingLot(parkingLotDto);
if (id != null)
{
return(CreatedAtAction(nameof(GetById), new { id = id }, parkingLotDto));
}
return(BadRequest());
}
private static ParkingLotDto GenerateParkingLotDto()
{
ParkingLotDto parkingLotDto = new ParkingLotDto
{
Name = "No.0",
Capacity = 4,
Location = "StreetAmazing",
};
return(parkingLotDto);
}
private static ParkingLotDto GenerateParkingLotDto()
{
ParkingLotDto parkingLotDto = new ParkingLotDto
{
Name = Guid.NewGuid().ToString(),
Capacity = 4,
Location = "StreetAmazing",
};
return(parkingLotDto);
}
