soundpress/Partsource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code-complete v2 vehicle API

Browse Source
This commit is contained in:
Tom Raterman
2020-07-26 21:52:36 -04:00
parent 48dc190027
commit f2ca3419b0
28 changed files with 1292 additions and 1001 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
PartSource.Services/Extensions/IQueryableExtensions.cs Normal file
View File

@@ -0,0 +1,83 @@
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using static System.Linq.Expressions.Expression;
namespace PartSource.Services.Extensions
{
public static class IQueryableExtensions
{
public static IQueryable<T> ApplyQueryDto<T>(this IQueryable<T> queryable, T dto)
{
foreach (PropertyInfo property in typeof(T).GetProperties())
{
object value = property.GetValue(dto);
if (IsFilterableValue(value))
{
queryable = queryable.Where(property, value);
}
}
return queryable;
}
private static IQueryable<T> Where<T>(this IQueryable<T> queryable, PropertyInfo property, object value)
{
if (property == null || value == null)
{
return queryable;
}
MemberExpression functions = Property(null, typeof(EF).GetProperty(nameof(EF.Functions)));
MethodInfo likeMethodInfo = typeof(DbFunctionsExtensions).GetMethod(nameof(DbFunctionsExtensions.Like), new Type[] { functions.Type, typeof(string), typeof(string) });
ParameterExpression lambdaParameter = Parameter(typeof(T), "x");
Expression expressionProperty = Property(lambdaParameter, property.Name);
if (property.PropertyType != typeof(string))
{
expressionProperty = Call(expressionProperty, typeof(object).GetMethod(nameof(object.ToString), new Type[0]));
}
MethodCallExpression methodCall = Call(
null,
likeMethodInfo,
functions,
expressionProperty,
Constant(value.ToString()));
return queryable.Where(Lambda<Func<T, bool>>(methodCall, lambdaParameter));
}
private static bool IsFilterableValue(object value)
{
switch (value)
{
case int i:
if (i == default) return false;
break;
case DateTime d:
if (d == default) return false;
break;
case string s:
if (string.IsNullOrEmpty(s)) return false;
break;
default:
if (value == null) return false;
break;
}
return true;
}
}
}

159
PartSource.Services/VehicleService.cs
View File

@@ -1,13 +1,15 @@
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;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace PartSource.Services
{
public class VehicleService
@@ -19,28 +21,102 @@ namespace PartSource.Services
_partSourceContext = partSourceContext;
}
public async Task<IList<VehicleMake>> GetAllMakes()
public async Task<IList<Vehicle>> GetVehicles(Vehicle vehicleQuery)
{
return await _partSourceContext.VehicleMakes.ToListAsync();
return await _partSourceContext.Vehicles
.ApplyQueryDto(vehicleQuery)
.ToListAsync();
}
public async Task<IList<VehicleData>> GetModels(int makeId, int year)
public async Task<Vehicle> GetVehicleById(int vehicleToEngineConfigId)
{
return await _partSourceContext.VehicleData.Where(d =>
d.MakeId == makeId
&& d.Year == year
)
.ToListAsync();
return await _partSourceContext.Vehicles
.FirstOrDefaultAsync(v => v.VehicleToEngineConfigId == vehicleToEngineConfigId);
}
public async Task<IList<BaseVehicle>> GetBaseVehicles(int makeId, int modelId, int year)
public async Task<Vehicle> GetVehicle(int baseVehicleId, int engineConfigId, int submodelId)
{
return await _partSourceContext.BaseVehicles.Where(d =>
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
)
.ToListAsync();
);
}
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)
@@ -57,30 +133,57 @@ namespace PartSource.Services
.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 == modelId
&& s.Year == year
)
.ToListAsync();
}
public async Task<VehicleData> GetVehicle(int baseVehicleId, int engineConfigId, int submodelId)
public async Task<SubmodelDto> GetSubmodelById(int submodelId)
{
return await _partSourceContext.VehicleData.FirstOrDefaultAsync(d =>
d.BaseVehicleId == baseVehicleId
&& d.EngineConfigId == engineConfigId
&& d.SubmodelId == 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<VehicleData> vehicles)
public IList<string> GetYmmFitment(IList<Vehicle> vehicles)
{
if (vehicles.Count == 0)
{
return null;
return new string[0];
}
IList<string> fitmentTags = new List<string>();
@@ -95,7 +198,7 @@ namespace PartSource.Services
List<string> years = vehicles
.Where(v => v.MakeName == make && v.ModelName == model)
.OrderBy(v => v.Year)
.Select(v => v.Year.HasValue ? v.Year.Value.ToString().Trim() : string.Empty)
.Select(v => v.Year.ToString().Trim())
.Distinct()
.ToList();
@@ -109,12 +212,12 @@ namespace PartSource.Services
return fitmentTags;
}
public IList<int> GetVehicleIdFitment(IList<VehicleData> vehicles)
public IList<int> GetVehicleIdFitment(IList<Vehicle> vehicles)
{
return vehicles.Select(v => v.VehicleToEngineConfigId).ToArray();
}
public IList<VehicleData> GetVehiclesForPart(string partNumber, string lineCode)
public IList<Vehicle> GetVehiclesForPart(string partNumber, string lineCode)
{
if (string.IsNullOrEmpty(partNumber) || string.IsNullOrEmpty(lineCode))
{
@@ -127,13 +230,13 @@ namespace PartSource.Services
.Where(d => d.LineCode == lineCode)
.Select(d => d.WhiCode);
IQueryable<VehicleData> vehicles = _partSourceContext.Fitments
IQueryable<Vehicle> vehicles = _partSourceContext.Fitments
.Where(f => f.PartNumber == partNumber && whiCodes.Contains(f.LineCode))
.Join(_partSourceContext.VehicleData,
.Join(_partSourceContext.Vehicles,
f => new { f.BaseVehicleId, f.EngineConfigId },
v => new { v.BaseVehicleId, v.EngineConfigId },
(f, v) => v);
return vehicles.ToList();
}
}