kailin parking lot api

ParkingLotApi/Controllers/ParkingLotsController.cs

@@ -0,0 +1,58 @@
+using Microsoft.AspNetCore.Mvc;
+using ParkingLotApi.Dtos;
+using ParkingLotApi.Exceptions;
+using ParkingLotApi.Models;
+using ParkingLotApi.Services;
+
+namespace ParkingLotApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class ParkingLotsController : ControllerBase
+    {
+        private ParkingLotService parkingLotService;
+
+        public ParkingLotsController(ParkingLotService parkingLotService)
+        {
+            this.parkingLotService = parkingLotService;
+        }
+
+        [HttpPost]
+        public async Task<ActionResult<ParkingLotDto>> CreateParkingLotAsync([FromBody] ParkingLotDto parkingLotDto)
+        {
+            //try
+            //{
+            return StatusCode(StatusCodes.Status201Created, await parkingLotService.CreateAsync(parkingLotDto));
+            //}
+            //catch (InvalidCapacityException ex)
+            //{
+            //    return BadRequest();
+            //}
+        }
+
+        [HttpDelete("id")]
+        public async Task<ActionResult<ParkingLotDto>> DeleteParkingLotAsync(string id)
+        {
+            await parkingLotService.DeleteParkingLot(id);
+            return new NoContentResult();
+        }
+
+        [HttpGet]
+        public async Task<ActionResult<List<ParkingLot>>> GetParkingLotsByPageInfoAsync(int pageIndex)
+        {
+            return await parkingLotService.GetParkingLotByPageInfo(pageIndex);
+        }
+
+        [HttpGet("{id}")]
+        public async Task<ActionResult<ParkingLot>> GetParkingLotByIdAsync(string id)
+        {
+            return await parkingLotService.GetParkingLotById(id);
+        }
+
+        [HttpPut("{id}")]
+        public async Task<ActionResult<ParkingLot>> UpdateParkingLotAsync(string id, [FromBody] ParkingLotDto parkingLotDto)
+        {
+            return await parkingLotService.UpdateParkingLot(id, parkingLotDto);
+        }
+    }
+}

ParkingLotApi/Dtos/ParkingLotDto.cs

@@ -0,0 +1,21 @@
+using ParkingLotApi.Models;
+
+namespace ParkingLotApi.Dtos
+{
+    public class ParkingLotDto
+    {
+        public string Name { get; set; }
+        public int Capacity {  get; set; }
+        public string Location { get; set; }
+
+        internal ParkingLot ToEntity()
+        {
+            return new ParkingLot()
+            {
+                Name = this.Name,
+                Capacity = this.Capacity,
+                Location = this.Location
+            };
+        }
+    }
+}

ParkingLotApi/Exceptions/InvalidCapacityException.cs

@@ -0,0 +1,6 @@
+namespace ParkingLotApi.Exceptions
+{
+    public class InvalidCapacityException : Exception
+    {
+    }
+}

ParkingLotApi/Exceptions/PageInfoInvalidException.cs

@@ -0,0 +1,6 @@
+namespace ParkingLotApi.Exceptions
+{
+    public class PageInfoInvalidException : Exception
+    {
+    }
+}

ParkingLotApi/Exceptions/ParkingLotNotFoundException.cs

@@ -0,0 +1,6 @@
+namespace ParkingLotApi.Exceptions
+{
+    public class ParkingLotNotFoundException : Exception
+    {
+    }
+}

ParkingLotApi/Filters/InvalidCapacityExceptionFilter.cs

@@ -0,0 +1,25 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using ParkingLotApi.Exceptions;
+
+namespace ParkingLotApi.Filters
+{
+    public class InvalidCapacityExceptionFilter : IActionFilter, IOrderedFilter
+    {
+        int IOrderedFilter.Order => int.MaxValue - 10;
+
+        void IActionFilter.OnActionExecuted(ActionExecutedContext context)
+        {
+            if (context.Exception is InvalidCapacityException invalidCapacityException)
+            {
+                context.Result = new BadRequestResult();
+                context.ExceptionHandled = true;
+            }
+        }
+
+        void IActionFilter.OnActionExecuting(ActionExecutingContext context)
+        {
+        }
+    }
+}

ParkingLotApi/Filters/PageInfoInvalidExceptionFilter.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using ParkingLotApi.Exceptions;
+
+namespace ParkingLotApi.Filters
+{
+    public class PageInfoInvalidExceptionFilter : IActionFilter, IOrderedFilter
+    {
+        int IOrderedFilter.Order => int.MaxValue - 10;
+
+        void IActionFilter.OnActionExecuted(ActionExecutedContext context)
+        {
+            if (context.Exception is PageInfoInvalidException pageInfoInvalidException)
+            {
+                context.Result = new BadRequestObjectResult(context.Exception.Message);
+                context.ExceptionHandled = true;
+            }
+        }
+
+        void IActionFilter.OnActionExecuting(ActionExecutingContext context)
+        {
+        }
+    }
+}

ParkingLotApi/Filters/ParkingLotNotFoundExceptionFilter.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc;
+using ParkingLotApi.Exceptions;
+
+namespace ParkingLotApi.Filters
+{
+    public class ParkingLotNotFoundExceptionFilter :IActionFilter, IOrderedFilter
+    {
+        int IOrderedFilter.Order => int.MaxValue - 10;
+
+        void IActionFilter.OnActionExecuted(ActionExecutedContext context)
+        {
+            if (context.Exception is ParkingLotNotFoundException parkingLotNotFoundException)
+            {
+                context.Result = new NotFoundObjectResult(context.Exception.Message);
+                context.ExceptionHandled = true;
+            }
+        }
+
+        void IActionFilter.OnActionExecuting(ActionExecutingContext context)
+        {
+        }
+    }
+}

ParkingLotApi/Models/ParkingLot.cs

@@ -0,0 +1,15 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace ParkingLotApi.Models
+{
+    public class ParkingLot
+    {
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        public string? Id { get; set; }
+        public string Name { get; set; }
+        public int Capacity { get; set; }
+        public string Location { get; set; }
+    }
+}

ParkingLotApi/Models/ParkingLotDatabaseSettings.cs

@@ -0,0 +1,9 @@
+namespace ParkingLotApi.Models
+{
+    public class ParkingLotDatabaseSettings
+    {
+        public string ConnectionString { get; set; } = null!;
+        public string DatabaseName { get; set; } = null!;
+        public string CollectionName { get; set; } = null!;
+    }
+}

ParkingLotApi/ParkingLotApi.csproj

@@ -8,6 +8,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.13" />
+    <PackageReference Include="MongoDB.Bson" Version="2.22.0" />
+    <PackageReference Include="MongoDB.Driver" Version="2.22.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>
 

ParkingLotApi/Program.cs

@@ -1,11 +1,23 @@
+using ParkingLotApi.Filters;
+using ParkingLotApi.Models;
+using ParkingLotApi.Repositories;
+using ParkingLotApi.Services;
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
 
-builder.Services.AddControllers();
+builder.Services.AddControllers(options =>
+{
+    options.Filters.Add<InvalidCapacityExceptionFilter>();
+});
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
+builder.Services.AddScoped<ParkingLotService>();
+builder.Services.AddSingleton<IParkingLotsRepository, ParkingLotsRepository>();
+builder.Services.Configure<ParkingLotDatabaseSettings>(
+    builder.Configuration.GetSection("ParkingLotStoreDatabase"));
 
 var app = builder.Build();
 
@@ -22,4 +34,6 @@
 
 app.MapControllers();
 
-app.Run();
+app.Run();
+
+public partial class Program { }

ParkingLotApi/Repositories/IParkingLotsRepository.cs

@@ -0,0 +1,14 @@
+using ParkingLotApi.Models;
+
+namespace ParkingLotApi.Repositories
+{
+    public interface IParkingLotsRepository
+    {
+        public Task<ParkingLot> CreateParkingLot(ParkingLot parking);
+        public Task<ParkingLot> GetParkingLotById(string id);
+        public Task DeleteParkingLotById(string id);
+        public Task<List<ParkingLot>> GetParkingLotByPageInfo(int pageIndex, int pageSize);
+        public Task<List<ParkingLot>> GetAllParkingLot();
+        public Task<ParkingLot> UpdateParkingLotInfo(string id, ParkingLot parkingLot);
+    }
+}

ParkingLotApi/Repositories/ParkingLotsRepository.cs

@@ -0,0 +1,51 @@
+using Microsoft.Extensions.Options;
+using MongoDB.Driver;
+using ParkingLotApi.Models;
+
+namespace ParkingLotApi.Repositories
+{
+    public class ParkingLotsRepository : IParkingLotsRepository
+    {
+        private readonly IMongoCollection<ParkingLot> parkingLotCollection;
+
+        public ParkingLotsRepository(IOptions<ParkingLotDatabaseSettings> parkingLotDatabaseSettings)
+        {
+            var mongoClient = new MongoClient(parkingLotDatabaseSettings.Value.ConnectionString);
+            var mongoDatabase = mongoClient.GetDatabase(parkingLotDatabaseSettings.Value.DatabaseName);
+            parkingLotCollection = mongoDatabase.GetCollection<ParkingLot>(parkingLotDatabaseSettings.Value.CollectionName);
+        }
+
+        public async Task<ParkingLot> CreateParkingLot(ParkingLot parkingLot)
+        {
+            await parkingLotCollection.InsertOneAsync(parkingLot);
+            return await parkingLotCollection.Find(a => a.Name == parkingLot.Name).FirstAsync();
+        }
+
+        public async Task<ParkingLot> GetParkingLotById(string id)
+        {
+            return await parkingLotCollection.Find(parkingLot => parkingLot.Id == id).FirstOrDefaultAsync();
+        }
+
+        public async Task DeleteParkingLotById(string id)
+        {
+            await parkingLotCollection.DeleteOneAsync(parkingLot => parkingLot.Id == id);
+        }
+
+        public async Task<List<ParkingLot>> GetParkingLotByPageInfo(int pageIndex, int pageSize)
+        {
+            return await parkingLotCollection.Find(parkingLot => true)
+                .Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
+        }
+
+        public async Task<List<ParkingLot>> GetAllParkingLot()
+        {
+            return await parkingLotCollection.Find(parkingLot => true).ToListAsync();
+        }
+
+        public async Task<ParkingLot> UpdateParkingLotInfo(string id, ParkingLot parkingLot)
+        {
+            await parkingLotCollection.ReplaceOneAsync(parkingLot => parkingLot.Id == id, parkingLot);
+            return parkingLot;
+        }
+    }
+}

ParkingLotApi/Services/ParkingLotService.cs

@@ -0,0 +1,82 @@
+using ParkingLotApi.Dtos;
+using ParkingLotApi.Exceptions;
+using ParkingLotApi.Models;
+using ParkingLotApi.Repositories;
+
+namespace ParkingLotApi.Services
+{
+    public class ParkingLotService
+    {
+        private readonly IParkingLotsRepository parkingLotsRepository;
+
+        public ParkingLotService(IParkingLotsRepository parkingLotsRepository)
+        {
+            this.parkingLotsRepository = parkingLotsRepository;
+        }
+
+        public async Task<ParkingLot> CreateAsync(ParkingLotDto parkingLotDto)
+        {
+            if (parkingLotDto.Capacity < 10)
+            {
+                throw new InvalidCapacityException();
+            }
+
+            return await parkingLotsRepository.CreateParkingLot(parkingLotDto.ToEntity());
+        }
+
+        public async Task DeleteParkingLot(string id)
+        {
+            if (await parkingLotsRepository.GetParkingLotById(id) == null)
+            {
+                throw new ParkingLotNotFoundException();
+            }
+            await parkingLotsRepository.DeleteParkingLotById(id);
+        }
+
+        public async Task<List<ParkingLot>> GetParkingLotByPageInfo(int pageIndex)
+        {
+            int pageSize = 15;
+
+            if (pageIndex < 0)
+            {
+                throw new PageInfoInvalidException();
+            }
+
+            if (pageIndex == 0)
+            {
+                return await parkingLotsRepository.GetAllParkingLot();
+            }
+            else
+            {
+                return await parkingLotsRepository.GetParkingLotByPageInfo(pageIndex, pageSize);
+            }
+        }
+
+        public async Task<ParkingLot> GetParkingLotById(string id)
+        {
+            ParkingLot parkingLot = await parkingLotsRepository.GetParkingLotById(id);
+
+            if (parkingLot == null)
+            {
+                throw new ParkingLotNotFoundException();
+            }
+
+            return parkingLot;
+        }
+
+        public async Task<ParkingLot> UpdateParkingLot(string id, ParkingLotDto parkingLotDto)
+        {
+            ParkingLot parkingLot = await parkingLotsRepository.GetParkingLotById(id);
+
+            if (parkingLot == null)
+            {
+                throw new ParkingLotNotFoundException();
+            }
+
+            parkingLot.Location = parkingLotDto.Location;
+            parkingLot.Capacity = (int)parkingLotDto.Capacity;
+
+            return await parkingLotsRepository.UpdateParkingLotInfo(id, parkingLot);
+        }
+    }
+}