Partsource/PartSource.Services/VehicleService.cs

using Microsoft.EntityFrameworkCore;
using PartSource.Data;
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 PartSourceContext _partSourceContext;

		public VehicleService(PartSourceContext partSourceContext)
		{
			_partSourceContext = partSourceContext;
		}

		public async Task<IList<Vehicle>> GetVehicles(Vehicle 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> GetVehicle(int baseVehicleId, int engineConfigId, int submodelId)
		{
			return await _partSourceContext.Vehicles.FirstOrDefaultAsync(d =>
				d.BaseVehicleId == baseVehicleId
				&& d.EngineConfigId == engineConfigId
				&& d.SubmodelId == submodelId
			);
		}

		public async Task<IList<VehicleMake>> GetMakes()
		{
			return await _partSourceContext.VehicleMakes
				.OrderBy(m => m.Name)
				.ToListAsync();
		}

		public async Task<IList<VehicleMake>> GetMakes(VehicleMake criteria)
		{
			return await _partSourceContext.VehicleMakes
				.ApplyQueryDto(criteria)
				.OrderBy(m => m.Name)
				.ToListAsync();
		}

		public async Task<VehicleMake> GetMakeById(int makeId)
		{
			return await _partSourceContext.VehicleMakes
				.FirstOrDefaultAsync(m => m.MakeId == makeId);
		}

		public async Task<IList<VehicleModel>> GetModels(VehicleModel criteria)
		{
			return await _partSourceContext.VehicleModels
				.ApplyQueryDto(criteria)
				.OrderBy(m => m.Name)
				.ToListAsync();
		}
		
		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();
		}

		public async Task<VehicleModel> GetModelById(int modelId)
		{
			return await _partSourceContext.VehicleModels
				.FirstOrDefaultAsync(m => m.ModelId == modelId);
		}


		public async Task<IList<BaseVehicle>> GetBaseVehicles(BaseVehicle criteria)
		{
			return await _partSourceContext.BaseVehicles
				.ApplyQueryDto(criteria)
				.ToListAsync();
		}

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

		public async Task<BaseVehicle> GetBaseVehicleById(int baseVehicleId)
		{
			return await _partSourceContext.BaseVehicles
				.FirstOrDefaultAsync(b => b.BaseVehicleId == baseVehicleId);
		}

		public async Task<IList<Engine>> GetEngines(Engine criteria)
		{
			return await _partSourceContext.Engines
				.ApplyQueryDto(criteria)
				.ToListAsync();
		}

		public async Task<IList<Engine>> GetEngines(int baseVehicleId)
		{
			return await _partSourceContext.Engines.Where(e => e.BaseVehicleId == baseVehicleId).ToListAsync();
		}

		public async Task<IList<Engine>> GetEngines(int baseVehicleId, int submodelId)
		{
			return await _partSourceContext.Engines.Where(e =>
				e.BaseVehicleId == baseVehicleId
				&& e.SubmodelId == submodelId
			)
			.ToListAsync();
		}

		public async Task<EngineDto> GetEngineById(int engineConfigId)
		{
			return await _partSourceContext.Engines
				.Where(e => e.EngineConfigId == engineConfigId)
				.Select(e => new EngineDto
				{
					EngineConfigId = e.EngineConfigId,
					Description = e.Description,
					Make = e.Make,
					MakeId = e.MakeId
				})
				.FirstOrDefaultAsync();
		}

		public async Task<IList<Submodel>> GetSubmodels(Submodel submodelQuery)
		{
			return await _partSourceContext.Submodels
				.ApplyQueryDto(submodelQuery)
				.ToListAsync();
		}

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

		public async Task<SubmodelDto> GetSubmodelById(int submodelId)
		{
			return await _partSourceContext.Submodels
				.Where(s => s.SubmodelId == submodelId)
				.Select(s => new SubmodelDto
				{
					Id = s.SubmodelId,
					Name = s.Name,
					Make = s.Make,
					MakeId = s.MakeId
				})
				.FirstOrDefaultAsync();
		}


		public IList<string> GetYmmFitment(IList<Vehicle> vehicles)
		{
			if (vehicles.Count == 0)
			{
				return new string[0];
			}

			IList<string> fitmentTags = new List<string>();

			IList<string> makeModels = vehicles.Select(v => $"{v.MakeName},{v.ModelName}").Distinct().ToList();

			foreach (string makeModel in makeModels)
			{
				string make = makeModel.Split(',')[0];
				string model = makeModel.Split(',')[1];

				List<string> years = vehicles
					.Where(v => v.MakeName == make && v.ModelName == model)
					.OrderBy(v => v.Year)
					.Select(v => v.Year.ToString().Trim())
					.Distinct()
					.ToList();

				string tag = $"{string.Join('-', years)} {make.Trim()} {model.Trim()}";

				System.Diagnostics.Debug.WriteLine(tag);

				fitmentTags.Add(tag);
			}

			return fitmentTags;
		}

		public IList<int> GetVehicleIdFitment(IList<Vehicle> vehicles)
		{
			return vehicles.Select(v => v.VehicleToEngineConfigId).ToArray();
		}

		public IList<Vehicle> GetVehiclesForPart(string partNumber, string lineCode)
		{
			if (string.IsNullOrEmpty(partNumber) || string.IsNullOrEmpty(lineCode))
			{
				return null;
			}

			partNumber = Regex.Replace(partNumber, "[^a-zA-Z0-9]", string.Empty);

			IQueryable<string> whiCodes = _partSourceContext.DcfMappings
				.Where(d => d.LineCode == lineCode)
				.Select(d => d.WhiCode);

			IQueryable<Vehicle> vehicles = _partSourceContext.Fitments
				.Where(f => f.PartNumber == partNumber && whiCodes.Contains(f.LineCode))
				.Join(_partSourceContext.Vehicles,
					f => new { f.BaseVehicleId, f.EngineConfigId },
					v => new { v.BaseVehicleId, v.EngineConfigId },
					(f, v) => v);

			return vehicles.ToList();
		}
	}
}