Code-complete v2 vehicle API

2020-07-26 21:52:36 -04:00
parent 48dc190027
commit f2ca3419b0
28 changed files with 1292 additions and 1001 deletions
--- a/PartSource.Api/Controllers/BaseApiController.cs
+++ b/PartSource.Api/Controllers/BaseApiController.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace PartSource.Api.Controllers
+{
+    public class BaseApiController : ControllerBase
+    {
+        public ActionResult ApiResponse<T>(T response)
+        {
+            switch (response)
+            {
+                case IList list:
+                    if (list.Count == 0)
+                    {
+                        return NoContent();
+                    }
+                    break;
+
+                default:
+                    if (response == null)
+                    {
+                        return NotFound();
+                    }
+                    break;
+            }
+
+            return Ok(response);
+        }
+    }
+}
--- a/PartSource.Api/Controllers/LegacyVehiclesController.cs
+++ b/PartSource.Api/Controllers/LegacyVehiclesController.cs
@@ -0,0 +1,152 @@
+using Microsoft.AspNetCore.Mvc;
+using PartSource.Data.Models;
+using PartSource.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+
+using NexpartMake = PartSource.Data.Nexpart.Make;
+using NexpartModel = PartSource.Data.Nexpart.Model;
+using NexpartEngine = PartSource.Data.Nexpart.Engine;
+using NexpartSubmodel = PartSource.Data.Nexpart.SubModel;
+
+namespace PartSource.Api.Controllers
+{
+    /// <summary>
+    /// This controller exists to enable legacy support for the old Nexpart-based vehicle lookup.
+    /// </summary>
+    [Obsolete]
+    [Route("vehicles")]
+    [ApiController]
+    public class LegacyVehiclesController : BaseNexpartController
+    {
+        private readonly VehicleService _vehicleService;
+
+        public LegacyVehiclesController(VehicleService vehicleService)
+        {
+            _vehicleService = vehicleService;
+        }
+
+        [HttpGet]
+        [Route("makes")]
+        public async Task<ActionResult> GetMakes()
+        {
+            IList<VehicleMake> vehicleMakes = await _vehicleService.GetMakes();
+            IList<NexpartMake> nexpartMakes = new List<NexpartMake>();
+
+            foreach (VehicleMake make in vehicleMakes)
+            {
+                nexpartMakes.Add(new NexpartMake
+                {
+                    Id = make.MakeId,
+                    Value = make.Name.Trim()
+                });
+            }
+
+            return Ok(new { data = new { make = nexpartMakes } });
+        }
+
+        [HttpGet]
+        [Route("models/makeid/{makeId}/modelyear/{year}")]
+        public async Task<ActionResult> GetModels(int makeId, int year)
+        {
+            IList<VehicleModel> vehicleModels = await _vehicleService.GetModels(makeId, year);
+            IList<NexpartModel> nexpartModels = new List<NexpartModel>();
+
+            foreach (VehicleModel model in vehicleModels)
+            {
+                nexpartModels.Add(new NexpartModel
+                {
+                    Id = model.ModelId,
+                    Value = model.Name.Trim()
+                });
+            }
+
+            return Ok(new { data = new[] { new { model = nexpartModels } } });
+        }
+
+        [HttpGet]
+        [Route("basevehicle/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")] 
+        [Route("basevehicles/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
+        public async Task<ActionResult> GetBaseVehicle(int makeId, int modelId, int year)
+        {
+            BaseVehicle baseVehicle = await _vehicleService.GetBaseVehicle(makeId, modelId, year);
+
+            return Ok(new { data = baseVehicle });
+        }
+
+        [HttpGet]
+        [Route("engines/basevehicleid/{baseVehicleId}")]
+        [Route("engines/basevehicleid/{baseVehicleId}/submodelid/{subModelId}")]
+        public async Task<ActionResult> GetEngines(int baseVehicleId, int? submodelId = null)
+        {
+            IList<NexpartEngine> nexpartEngines = new List<NexpartEngine>();
+            IList<Engine> engines = submodelId == null
+                ? await _vehicleService.GetEngines(baseVehicleId)
+                : await _vehicleService.GetEngines(baseVehicleId, (int)submodelId);
+
+            foreach(Engine engine in engines)
+            {
+                nexpartEngines.Add(new NexpartEngine
+                {
+                    Id = engine.EngineConfigId,
+                    Value = engine.Description.Trim()
+                });
+            }
+
+            return Ok(new { data = new { engine = nexpartEngines } });
+        }
+
+        [HttpGet]
+        [Route("trim/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
+        [Route("submodels/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
+        public async Task<ActionResult> GetSubmodels(int makeId, int modelId, int year)
+        {
+            IList<Submodel> submodels = await _vehicleService.GetSubmodels(makeId, modelId, year);
+            IList<NexpartSubmodel> nexpartSubmodels = new List<NexpartSubmodel>();
+
+            foreach (Submodel submodel in submodels)
+            {
+                nexpartSubmodels.Add(new NexpartSubmodel
+                {
+                    Id = submodel.SubmodelId.ToString(),
+                    Description = submodel.Name.Trim()
+                });
+            }
+
+            return Ok(new { data = new { subModel = submodels } });
+        }
+
+        [HttpGet]
+        [Route("detail/basevehicleid/{baseVehicleId}/submodelid/{submodelId}/engineconfigid/{engineConfigId}")]
+        public async Task<ActionResult> GetVehicleDetail(int baseVehicleId, int submodelId, int engineConfigId)
+        {
+            Vehicle vehicle = await _vehicleService.GetVehicle(baseVehicleId, engineConfigId, submodelId);
+
+            return Ok(new { data = vehicle });
+        }
+
+        [HttpGet]
+        [Route("types")]
+        public ActionResult GetVehicleTypes()
+        {
+            return new StatusCodeResult((int)HttpStatusCode.Gone);
+        }
+
+        [HttpGet]
+        [Route("makes/vehicletypeid/{vehicleTypeId}")]
+        public ActionResult GetMakes(int vehicleTypeId)
+        {
+            return new StatusCodeResult((int)HttpStatusCode.Gone);
+        }
+
+        [HttpGet]
+        [Route("models/makeid/{makeId}/modelyear/{year}/vehicletypeid/{vehicleTypeId}")]
+        public ActionResult GetModels(int makeId, int year, int vehicleTypeId)
+        {
+            return new StatusCodeResult((int)HttpStatusCode.Gone);
+        }
+    }
+}
--- a/PartSource.Api/Controllers/VehiclesController.cs
+++ b/PartSource.Api/Controllers/VehiclesController.cs
@@ -1,101 +1,132 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using PartSource.Data.Dtos;
 using PartSource.Data.Models;
 using PartSource.Services;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Threading.Tasks;

 namespace PartSource.Api.Controllers
 {
-    [Route("[controller]")]
-    [ApiController]
-    public class VehiclesController : BaseNexpartController
-    {
-        private readonly VehicleService _vehicleService;
+	[Route("v2/[controller]")]
+	[ApiController]
+	public class VehiclesController : BaseApiController
+	{
+		private readonly VehicleService _vehicleService;

-        public VehiclesController(VehicleService vehicleService)
-        {
-            this._vehicleService = vehicleService;
-        }
+		public VehiclesController(VehicleService vehicleService)
+		{
+			_vehicleService = vehicleService;
+		}

-        [HttpGet]
-        [Route("makes")]
-        public async Task<ActionResult> GetMakes()
-        {
-            IList<VehicleMake> makes = await _vehicleService.GetAllMakes();
+		[HttpGet]
+		[Route("")]
+		public async Task<ActionResult> GetVehicles([FromQuery] Vehicle vehicleQuery)
+		{
+			IList<Vehicle> vehicles = await _vehicleService.GetVehicles(vehicleQuery);

-            return Ok(makes);
-        }
+			return ApiResponse(vehicles);
+		}

-        [HttpGet]
-        [Route("models/makeid/{makeId}/modelyear/{year}")]
-        public async Task<ActionResult> GetModels(int makeId, int year)
-        {
-            IList<VehicleData> models = await _vehicleService.GetModels(makeId, year);
+		[HttpGet]
+		[Route("{id}")]
+		public async Task<ActionResult> GetVehicleById(int id)
+		{
+			Vehicle vehicle = await _vehicleService.GetVehicleById(id);

-            return Ok(models);
-        }
+			return ApiResponse(vehicle);
+		}

-        [HttpGet]
-        [Route("basevehicle/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")] 
-        [Route("basevehicles/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
-        public async Task<ActionResult> GetBaseVehicle(int makeId, int modelId, int year)
-        {
-            IList<BaseVehicle> baseVehicles = await _vehicleService.GetBaseVehicles(makeId, modelId, year);
+		[HttpGet]
+		[Route("makes")]
+		public async Task<ActionResult> GetMakes([FromQuery] VehicleMake vehicleMake)
+		{
+			IList<VehicleMake> makes = await _vehicleService.GetMakes(vehicleMake);

-            return Ok(baseVehicles);
-        }
+			return ApiResponse(makes);
+		}

-        [HttpGet]
-        [Route("engines/basevehicleid/{baseVehicleId}")]
-        [Route("engines/basevehicleid/{baseVehicleId}/submodelid/{subModelId}")]
-        public async Task<ActionResult> GetEngines(int baseVehicleId, int? submodelId = null)
-        {
-            IList<Engine> engines = submodelId == null
-                ? await _vehicleService.GetEngines(baseVehicleId)
-                : await _vehicleService.GetEngines(baseVehicleId, (int)submodelId);
+		[HttpGet]
+		[Route("makes/{id}")]
+		public async Task<ActionResult> GetMakeById(int id)
+		{
+			VehicleMake make = await _vehicleService.GetMakeById(id);

-            return Ok(engines);
-        }
+			return ApiResponse(make);
+		}

-        [HttpGet]
-        [Route("trim/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
-        [Route("submodels/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
-        public async Task<ActionResult> GetSubmodels(int makeId, int modelId, int year)
-        {
-            IList<Submodel> submodels = await _vehicleService.GetSubmodels(makeId, modelId, year);
+		[HttpGet]
+		[Route("models")]
+		public async Task<ActionResult> GetModels([FromQuery] VehicleModel vehicleModel)
+		{
+			IList<VehicleModel> models = await _vehicleService.GetModels(vehicleModel);

-            return Ok(submodels);
-        }
+			return ApiResponse(models);
+		}

-        [HttpGet]
-        [Route("/detail/basevehicleid/{baseVehicleId}/submodelid/{submodelId}/engineconfigid/{engineConfigId}")]
-        public async Task<ActionResult> GetVehicleDetail(int baseVehicleId, int submodelId, int engineConfigId)
-        {
-            VehicleData vehicle = await _vehicleService.GetVehicle(baseVehicleId, engineConfigId, submodelId);
+		[HttpGet]
+		[Route("models/{id}")]
+		public async Task<ActionResult> GetModelById(int id)
+		{
+			VehicleModel model = await _vehicleService.GetModelById(id);

-            return Ok(vehicle);
-        }
+			return ApiResponse(model);
+		}

-        [HttpGet]
-        [Route("types")]
-        public ActionResult GetVehicleTypes()
-        {
-            return new StatusCodeResult((int)HttpStatusCode.Gone);
-        }
+		[HttpGet]
+		[Route("basevehicles")]
+		public async Task<ActionResult> GetBaseVehicles([FromQuery] BaseVehicle baseVehicle)
+		{
+			IList<BaseVehicle> baseVehicles = await _vehicleService.GetBaseVehicles(baseVehicle);

-        [HttpGet]
-        [Route("makes/vehicletypeid/{vehicleTypeId}")]
-        public ActionResult GetMakes(int vehicleTypeId)
-        {
-            return new StatusCodeResult((int)HttpStatusCode.Gone);
-        }
+			return ApiResponse(baseVehicles);
+		}

-        [HttpGet]
-        [Route("models/makeid/{makeId}/modelyear/{year}/vehicletypeid/{vehicleTypeId}")]
-        public ActionResult GetModels(int makeId, int year, int vehicleTypeId)
-        {
-            return new StatusCodeResult((int)HttpStatusCode.Gone);
-        }
-    }
+		[HttpGet]
+		[Route("basevehicles/{id}")]
+		public async Task<ActionResult> GetBaseVehicleById(int id)
+		{
+			BaseVehicle baseVehicle = await _vehicleService.GetBaseVehicleById(id);
+
+			return ApiResponse(baseVehicle);
+		}
+
+		[HttpGet]
+		[Route("engines")]
+		public async Task<ActionResult> GetEngines([FromQuery] Engine engine)
+		{
+			IList<Engine> engines = await _vehicleService.GetEngines(engine);
+
+			return ApiResponse(engines);
+		}
+
+		[HttpGet]
+		[Route("engines/{id}")]
+		public async Task<ActionResult> GetEngineById(int id)
+		{
+			EngineDto engine = await _vehicleService.GetEngineById(id);
+
+			return ApiResponse(engine);
+		}
+
+		[HttpGet]
+		[Route("submodels")]
+		public async Task<ActionResult> GetSubmodels([FromQuery] Submodel submodelQuery)
+		{
+			IList<Submodel> submodels = await _vehicleService.GetSubmodels(submodelQuery);
+
+			return ApiResponse(submodels);
+		}
+
+		[HttpGet]
+		[Route("submodels/{id}")]
+		public async Task<ActionResult> GetSubmodels(int id)
+		{
+			SubmodelDto submodel = await _vehicleService.GetSubmodelById(id);
+
+			return ApiResponse(submodel);
+		}
+	}
 }