Publish to Sound Press dev ops

PartSource.Services/VehicleService.cs

@@ -1,237 +1,262 @@
-using AutoMapper;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
-using PartSource.Data;
 using PartSource.Data.Contexts;
 using PartSource.Data.Dtos;
 using PartSource.Data.Models;
 using PartSource.Services.Extensions;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
 
 namespace PartSource.Services
 {
-	public class VehicleService
-	{
-		private readonly IMapper _mapper;
-		private readonly PartSourceContext _partSourceContext;
+    public class VehicleService
+    {
+        private readonly PartSourceContext _partSourceContext;
 
-		public VehicleService(IMapper mapper, PartSourceContext partSourceContext)
-		{
-			_mapper = mapper;
-			_partSourceContext = partSourceContext;
-		}
+        public VehicleService(PartSourceContext partSourceContext)
+        {
+            _partSourceContext = partSourceContext;
+        }
 
-		public async Task<IList<Vehicle>> GetVehicles(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.ToListAsync();
-		}
+        public async Task<IList<Vehicle>> GetVehicles(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .ToListAsync();
+        }
 
-		public async Task<Vehicle> GetVehicleById(int vehicleToEngineConfigId)
-		{
-			return await _partSourceContext.Vehicles
-				.FirstOrDefaultAsync(v => v.VehicleToEngineConfigId == vehicleToEngineConfigId);
-		}
+        public async Task<Vehicle> GetVehicleById(int vehicleToEngineConfigId)
+        {
+            return await _partSourceContext.Vehicles
+                .FirstOrDefaultAsync(v => v.VehicleToEngineConfigId == vehicleToEngineConfigId);
+        }
 
-		public async Task<IList<MakeDto>> GetMakes(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.Select(v => new MakeDto
-				{
-					MakeId = v.MakeId,
-					MakeName = v.MakeName
+        public async Task<IList<MakeDto>> GetMakes(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .Select(v => new MakeDto
+                {
+                    MakeId = v.MakeId,
+                    MakeName = v.MakeName
 
-				})
-				.Distinct()
-				.OrderBy(v => v.MakeName)
-				.ToListAsync();
-		}
+                })
+                .Distinct()
+                .OrderBy(v => v.MakeName)
+                .ToListAsync();
+        }
 
-		public async Task<MakeDto> GetMakeById(int makeId)
-		{
-			Vehicle vehicle = await _partSourceContext.Vehicles
-				.Where(v => v.MakeId == makeId)
-				.FirstOrDefaultAsync();
+        public async Task<MakeDto> GetMakeById(int makeId)
+        {
+            Vehicle vehicle = await _partSourceContext.Vehicles
+                .Where(v => v.MakeId == makeId)
+                .FirstOrDefaultAsync();
 
-			return _mapper.Map<MakeDto>(vehicle);
-		}
+            return new MakeDto
+            {
+                MakeId = vehicle.MakeId,
+                MakeName = vehicle.MakeName
+            };
+        }
 
-		public async Task<IList<ModelDto>> GetModels(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.Select(v => new ModelDto
-				{
-					ModelId = v.ModelId,
-					ModelName = v.ModelName,
-					MakeId = v.MakeId,
-					MakeName = v.MakeName
-				})
-				.Distinct()
-				.OrderBy(m => m.ModelName)
-				.ToListAsync();
-		}
+        public async Task<IList<ModelDto>> GetModels(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .Select(v => new ModelDto
+                {
+                    ModelId = v.ModelId,
+                    ModelName = v.ModelName,
+                    MakeId = v.MakeId,
+                    MakeName = v.MakeName
+                })
+                .Distinct()
+                .OrderBy(m => m.ModelName)
+                .ToListAsync();
+        }
 
-		public async Task<ModelDto> GetModelById(int modelId)
-		{
-			Vehicle vehicle = await _partSourceContext.Vehicles
-				.Where(m => m.ModelId == modelId)
-				.FirstOrDefaultAsync();
+        public async Task<ModelDto> GetModelById(int modelId)
+        {
+            Vehicle vehicle = await _partSourceContext.Vehicles
+                .Where(m => m.ModelId == modelId)
+                .FirstOrDefaultAsync();
 
-			return _mapper.Map<ModelDto>(vehicle);
-		}
+            return new ModelDto
+            {
+                MakeId = vehicle.MakeId,
+                MakeName = vehicle.MakeName,
+                ModelId = vehicle.ModelId,
+                ModelName = vehicle.ModelName
+            };
+        }
 
 
-		public async Task<IList<BaseVehicleDto>> GetBaseVehicles(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.Select(v => new BaseVehicleDto
-				{
-					BaseVehicleId = v.BaseVehicleId,
-					MakeName = v.MakeName,
-					MakeId = v.MakeId,
-					ModelName = v.ModelName,
-					ModelId = v.ModelId,
-					Year = v.Year
-				})
-				.Distinct()
-				.ToListAsync();
-		}
+        public async Task<IList<BaseVehicleDto>> GetBaseVehicles(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .Select(v => new BaseVehicleDto
+                {
+                    BaseVehicleId = v.BaseVehicleId,
+                    MakeName = v.MakeName,
+                    MakeId = v.MakeId,
+                    ModelName = v.ModelName,
+                    ModelId = v.ModelId,
+                    Year = v.Year
+                })
+                .Distinct()
+                .ToListAsync();
+        }
 
-		public async Task<BaseVehicleDto> GetBaseVehicleById(int baseVehicleId)
-		{
-			Vehicle vehicle = await _partSourceContext.Vehicles
-				.Where(b => b.BaseVehicleId == baseVehicleId)
-				.FirstOrDefaultAsync();
+        public async Task<BaseVehicleDto> GetBaseVehicleById(int baseVehicleId)
+        {
+            Vehicle vehicle = await _partSourceContext.Vehicles
+                .Where(b => b.BaseVehicleId == baseVehicleId)
+                .FirstOrDefaultAsync();
 
-			return _mapper.Map<BaseVehicleDto>(vehicle);
-		}
+            return new BaseVehicleDto
+            {
+                MakeId = vehicle.MakeId,
+                MakeName = vehicle.MakeName,
+                ModelId = vehicle.ModelId,
+                ModelName = vehicle.ModelName,
+                Year = vehicle.Year,
+                BaseVehicleId = vehicle.BaseVehicleId
+            };
+        }
 
-		public async Task<IList<EngineDto>> GetEngines(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.Select(v => new EngineDto
-				{
-					EngineConfigId = v.EngineConfigId,
-					EngineDescription = v.EngineDescription,
-					MakeName = v.MakeName,
-					MakeId = v.MakeId
-				})
-				.Distinct()
-				.ToListAsync();
-		}
+        public async Task<IList<EngineDto>> GetEngines(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .Select(v => new EngineDto
+                {
+                    EngineConfigId = v.EngineConfigId,
+                    EngineDescription = v.EngineDescription,
+                    MakeName = v.MakeName,
+                    MakeId = v.MakeId
+                })
+                .Distinct()
+                .ToListAsync();
+        }
 
-		public async Task<EngineDto> GetEngineById(int engineConfigId)
-		{
-			Vehicle vehicle = await _partSourceContext.Vehicles
-				.Where(e => e.EngineConfigId == engineConfigId)
-				.FirstOrDefaultAsync();
+        public async Task<EngineDto> GetEngineById(int engineConfigId)
+        {
+            Vehicle vehicle = await _partSourceContext.Vehicles
+                .Where(e => e.EngineConfigId == engineConfigId)
+                .FirstOrDefaultAsync();
 
-			return _mapper.Map<EngineDto>(vehicle);
-		}
+            return new EngineDto
+            {
+                MakeId = vehicle.MakeId,
+                MakeName = vehicle.MakeName,
+                EngineConfigId = vehicle.EngineConfigId,
+                EngineDescription = vehicle.EngineDescription
+            };
+        }
 
-		public async Task<IList<SubmodelDto>> GetSubmodels(VehicleDto vehicleQuery)
-		{
-			return await _partSourceContext.Vehicles
-				.ApplyQueryDto(vehicleQuery)
-				.GroupBy(v => new { v.SubmodelId, v.SubmodelName, v.MakeId, v.MakeName })
-				.Select(v => new SubmodelDto
-				{
-					SubmodelId = v.Key.SubmodelId,
-					SubmodelName = v.Key.SubmodelName,
-					MakeId = v.Key.MakeId,
-					MakeName = v.Key.MakeName
-				})
-				.Distinct()
-				.ToListAsync();
-		}
+        public async Task<IList<SubmodelDto>> GetSubmodels(VehicleDto vehicleQuery)
+        {
+            return await _partSourceContext.Vehicles
+                .ApplyQueryDto(vehicleQuery)
+                .GroupBy(v => new { v.SubmodelId, v.SubmodelName, v.MakeId, v.MakeName })
+                .Select(v => new SubmodelDto
+                {
+                    SubmodelId = v.Key.SubmodelId,
+                    SubmodelName = v.Key.SubmodelName,
+                    MakeId = v.Key.MakeId,
+                    MakeName = v.Key.MakeName
+                })
+                .Distinct()
+                .ToListAsync();
+        }
 
-		public async Task<SubmodelDto> GetSubmodelById(int submodelId)
-		{
-			Vehicle vehicle = await _partSourceContext.Vehicles
-				.Where(s => s.SubmodelId == submodelId)
-				.FirstOrDefaultAsync();
+        public async Task<SubmodelDto> GetSubmodelById(int submodelId)
+        {
+            Vehicle vehicle = await _partSourceContext.Vehicles
+                .Where(s => s.SubmodelId == submodelId)
+                .FirstOrDefaultAsync();
 
-			return _mapper.Map<SubmodelDto>(vehicle);
-		}
+            return new SubmodelDto { 
+                SubmodelName = vehicle.SubmodelName,
+                SubmodelId = vehicle.SubmodelId,
+                MakeId= vehicle.MakeId,
+                MakeName = vehicle.MakeName
+            };
 
-		#region Legacy API Support
+        }
 
-		[Obsolete]
-		public async Task<Vehicle> GetVehicle(int baseVehicleId, int engineConfigId, int submodelId)
-		{
-			return await _partSourceContext.Vehicles.FirstOrDefaultAsync(d =>
-				d.BaseVehicleId == baseVehicleId
-				&& d.EngineConfigId == engineConfigId
-				&& d.SubmodelId == submodelId
-			);
-		}
+        #region Legacy API Support
 
-		[Obsolete]
-		public async Task<IList<Submodel>> GetSubmodels(int makeId, int modelId, int year)
-		{
-			return await _partSourceContext.Submodels.Where(s =>
-				s.MakeId == makeId
-				&& s.ModelId == modelId
-				&& s.Year == year
-			)
-			.ToListAsync();
-		}
+        [Obsolete]
+        public async Task<Vehicle> GetVehicle(int baseVehicleId, int engineConfigId, int submodelId)
+        {
+            return await _partSourceContext.Vehicles.FirstOrDefaultAsync(d =>
+                d.BaseVehicleId == baseVehicleId
+                && d.EngineConfigId == engineConfigId
+                && d.SubmodelId == submodelId
+            );
+        }
 
-		[Obsolete]
-		public async Task<IList<Engine>> GetEngines(int baseVehicleId)
-		{
-			return await _partSourceContext.Engines.Where(e => e.BaseVehicleId == baseVehicleId).ToListAsync();
-		}
+        [Obsolete]
+        public async Task<IList<Submodel>> GetSubmodels(int makeId, int modelId, int year)
+        {
+            return await _partSourceContext.Submodels.Where(s =>
+                s.MakeId == makeId
+                && s.ModelId == modelId
+                && s.Year == year
+            )
+            .ToListAsync();
+        }
 
-		[Obsolete]
-		public async Task<IList<Engine>> GetEngines(int baseVehicleId, int submodelId)
-		{
-			return await _partSourceContext.Engines.Where(e =>
-				e.BaseVehicleId == baseVehicleId
-				&& e.SubmodelId == submodelId
-			)
-			.ToListAsync();
-		}
+        [Obsolete]
+        public async Task<IList<Engine>> GetEngines(int baseVehicleId)
+        {
+            return await _partSourceContext.Engines.Where(e => e.BaseVehicleId == baseVehicleId).ToListAsync();
+        }
 
-		[Obsolete]
-		public async Task<BaseVehicle> GetBaseVehicle(int makeId, int modelId, int year)
-		{
-			return await _partSourceContext.BaseVehicles.FirstOrDefaultAsync(d =>
-				d.MakeId == makeId
-				&& d.ModelId == modelId
-				&& d.Year == year
-			);
-		}
+        [Obsolete]
+        public async Task<IList<Engine>> GetEngines(int baseVehicleId, int submodelId)
+        {
+            return await _partSourceContext.Engines.Where(e =>
+                e.BaseVehicleId == baseVehicleId
+                && e.SubmodelId == submodelId
+            )
+            .ToListAsync();
+        }
 
-		[Obsolete]
-		public async Task<IList<VehicleModel>> GetModels(int makeId, int year)
-		{
-			return await _partSourceContext.VehicleModels
-				.Where(m =>
-					m.MakeId == makeId
-					&& m.Year == year
-				)
-				.OrderBy(d => d.Name)
-				.ToListAsync();
-		}
+        [Obsolete]
+        public async Task<BaseVehicle> GetBaseVehicle(int makeId, int modelId, int year)
+        {
+            return await _partSourceContext.BaseVehicles.FirstOrDefaultAsync(d =>
+                d.MakeId == makeId
+                && d.ModelId == modelId
+                && d.Year == year
+            );
+        }
 
-		[Obsolete]
-		public async Task<IList<VehicleMake>> GetMakes()
-		{
-			return await _partSourceContext.VehicleMakes
-				.OrderBy(m => m.Name)
-				.ToListAsync();
-		}
-		#endregion
-	}
+        [Obsolete]
+        public async Task<IList<VehicleModel>> GetModels(int makeId, int year)
+        {
+            return await _partSourceContext.VehicleModels
+                .Where(m =>
+                    m.MakeId == makeId
+                    && m.Year == year
+                )
+                .OrderBy(d => d.Name)
+                .ToListAsync();
+        }
+
+        [Obsolete]
+        public async Task<IList<VehicleMake>> GetMakes()
+        {
+            return await _partSourceContext.VehicleMakes
+                .OrderBy(m => m.Name)
+                .ToListAsync();
+        }
+        #endregion
+    }
 }