Partsource/PartSource.Services/VehicleService.cs

using AutoMapper;
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 VehicleService(IMapper mapper, PartSourceContext partSourceContext)
		{
			_mapper = mapper;
			_partSourceContext = partSourceContext;
		}

		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<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();
		}

		public async Task<MakeDto> GetMakeById(int makeId)
		{
			Vehicle vehicle = await _partSourceContext.Vehicles
				.Where(v => v.MakeId == makeId)
				.FirstOrDefaultAsync();

			return _mapper.Map<MakeDto>(vehicle);
		}

		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();

			return _mapper.Map<ModelDto>(vehicle);
		}


		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();

			return _mapper.Map<BaseVehicleDto>(vehicle);
		}

		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();

			return _mapper.Map<EngineDto>(vehicle);
		}

		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();

			return _mapper.Map<SubmodelDto>(vehicle);
		}

		#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
			);
		}

		[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)
		{
			return await _partSourceContext.Engines.Where(e => e.BaseVehicleId == baseVehicleId).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<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<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
	}
}