public async Task <IEnumerable <IEmployee> > GetAllAsync(IEmployeeParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <EmployeeEntity> >(parameters);
if (GenericParameters.Paged)
{
switch (GenericParameters.SortOrder)
{
case "Name":
GenericParameters.OrderBy = source => source.OrderBy(e => e.Name);
break;
case "name_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(e => e.Name);
break;
default:
GenericParameters.OrderBy = source => source.OrderBy(e => e.ID);
break;
}
GenericParameters.Skip = (GenericParameters.PageNumber - 1) * GenericParameters.PageSize;
GenericParameters.Take = GenericParameters.PageSize;
}
if (!String.IsNullOrEmpty(parameters.SearchString))
{
GenericParameters.Filter = e => e.Name.Contains(GenericParameters.SearchString);
}
var employeeList = (Mapper.Map <List <IEmployee> >(await Repository.GetAllAsync(GenericParameters)));
return(employeeList);
}
private IQueryable <TEntity> GetQueryable <TEntity>(IGenericRepositoryParameters <TEntity> parameters) where TEntity : class, IBaseEntity
{
parameters.IncludeProperties = parameters.IncludeProperties ?? string.Empty;
IQueryable <TEntity> query = Context.Set <TEntity>();
if (parameters.Filter != null)
{
query = query.Where(parameters.Filter);
}
foreach (var includeProperty in parameters.IncludeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
if (parameters.OrderBy != null)
{
query = parameters.OrderBy(query);
}
if (parameters.Skip.HasValue)
{
query = query.Skip(parameters.Skip.Value);
}
if (parameters.Take.HasValue)
{
query = query.Take(parameters.Take.Value);
}
return(query);
}
public async Task <IEmployee> GetOneAsync(IEmployeeParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <EmployeeEntity> >(parameters);
GenericParameters.Filter = e => e.ID == GenericParameters.ID;
var employee = (Mapper.Map <IEmployee>(await Repository.GetOneAsync(GenericParameters)));
return(employee);
}
public async Task <IAssignment> GetOneAsync(IAssignmentParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <AssignmentEntity> >(parameters);
GenericParameters.Filter = e => e.ID == GenericParameters.ID;
var assignment = (Mapper.Map <IAssignment>(await Repository.GetOneAsync(GenericParameters)));
return(assignment);
}
public async Task <IEnumerable <IItem> > GetAllAsync(IItemParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <ItemEntity> >(parameters);
if (GenericParameters.Paged)
{
if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock != true)
{
GenericParameters.Filter = i => i.Name.Contains(GenericParameters.SearchString);
}
else if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock == true)
{
GenericParameters.Filter = i => i.Name.Contains(GenericParameters.SearchString) && i.EmployeeID == null;
}
else if (parameters.OnStock == true)
{
GenericParameters.Filter = i => i.EmployeeID == null;
}
switch (GenericParameters.SortOrder)
{
case "Name":
GenericParameters.OrderBy = source => source.OrderBy(i => i.Name);
break;
case "name_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(i => i.Name);
break;
case "Description":
GenericParameters.OrderBy = source => source.OrderBy(i => i.Description);
break;
case "description_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(i => i.Name);
break;
case "Employee":
GenericParameters.OrderBy = source => source.OrderBy(i => i.Employee.Name);
break;
case "employee_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(i => i.Employee.Name);
break;
default:
GenericParameters.OrderBy = source => source.OrderBy(i => i.ID);
break;
}
GenericParameters.Skip = (GenericParameters.PageNumber - 1) * GenericParameters.PageSize;
GenericParameters.Take = GenericParameters.PageSize;
}
var itemList = (Mapper.Map <List <IItem> >(await Repository.GetAllAsync(GenericParameters)));
return(itemList);
}
public async Task <IEnumerable <IMeasuringDevice> > GetAllAsync(IMeasuringDeviceParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <MeasuringDeviceEntity> >(parameters);
if (GenericParameters.Paged)
{
if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock != true)
{
GenericParameters.Filter = MD => MD.Name.Contains(parameters.SearchString);
}
else if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock == true)
{
GenericParameters.Filter = MD => MD.Name.Contains(parameters.SearchString) && MD.EmployeeID == null;
}
else if (parameters.OnStock == true)
{
GenericParameters.Filter = MD => MD.EmployeeID == null;
}
switch (GenericParameters.SortOrder)
{
case "Name":
GenericParameters.OrderBy = source => source.OrderBy(MD => MD.Name);
break;
case "name_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(MD => MD.Name);
break;
case "CalibrationExpirationDate":
GenericParameters.OrderBy = source => source.OrderBy(MD => MD.CalibrationExpirationDate);
break;
case "calibrationExpirationDate_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(MD => MD.CalibrationExpirationDate);
break;
case "Employee":
GenericParameters.OrderBy = source => source.OrderBy(MD => MD.Employee.Name);
break;
case "employee_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(MD => MD.Employee.Name);
break;
default:
GenericParameters.OrderBy = source => source.OrderBy(MD => MD.ID);
break;
}
GenericParameters.Skip = (GenericParameters.PageNumber - 1) * GenericParameters.PageSize;
GenericParameters.Take = GenericParameters.PageSize;
}
var measuringDeviceList = (Mapper.Map <List <IMeasuringDevice> >(await Repository.GetAllAsync(GenericParameters)));
return(measuringDeviceList);
}
public ItemRepository(IGenericRepository repository, IGenericRepositoryParameters <ItemEntity> parameters)
{
this.Repository = repository;
this.GenericParameters = parameters;
}
public EmployeeRepository(IGenericRepository repository, IGenericRepositoryParameters <EmployeeEntity> parameters)
{
this.Repository = repository;
this.GenericParameters = parameters;
}
public virtual Task <int> GetCountAsync <TEntity>(IGenericRepositoryParameters <TEntity> parameters) where TEntity : class, IBaseEntity
{
return(GetQueryable(parameters).CountAsync());
}
public virtual async Task <TEntity> GetOneAsync <TEntity>(IGenericRepositoryParameters <TEntity> parameters) where TEntity : class, IBaseEntity
{
return(await GetQueryable(parameters).SingleOrDefaultAsync());
}
public virtual async Task <IEnumerable <TEntity> > GetAllAsync <TEntity>(IGenericRepositoryParameters <TEntity> parameters) where TEntity : class, IBaseEntity
{
return(await GetQueryable <TEntity>(parameters).ToListAsync());
}
public AssignmentRepository(IGenericRepository repository, IGenericRepositoryParameters <AssignmentEntity> parameters)
{
this.Repository = repository;
this.GenericParameters = parameters;
}
public async Task <IEnumerable <IVehicle> > GetAllAsync(IVehicleParameters parameters)
{
GenericParameters = Mapper.Map <IGenericRepositoryParameters <VehicleEntity> >(parameters);
if (parameters.Paged)
{
if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock != true)
{
GenericParameters.Filter = v => v.Name.Contains(GenericParameters.SearchString);
}
else if (!String.IsNullOrEmpty(GenericParameters.SearchString) && parameters.OnStock == true)
{
GenericParameters.Filter = v => v.Name.Contains(GenericParameters.SearchString) && v.EmployeeID == null;
}
else if (parameters.OnStock == true)
{
GenericParameters.Filter = v => v.EmployeeID == null;
}
#region Possible to add orderby and dec/asc field to parameters to reduce code here
switch (GenericParameters.SortOrder)
{
case "Name":
GenericParameters.OrderBy = source => source.OrderBy(v => v.Name);
break;
case "name_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.Name);
break;
case "Type":
GenericParameters.OrderBy = source => source.OrderBy(v => v.Type);
break;
case "type_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.Type);
break;
case "LicenseExpirationDate":
GenericParameters.OrderBy = source => source.OrderBy(v => v.LicenseExpirationDate);
break;
case "licenseExpirationDate_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.LicenseExpirationDate);
break;
case "Mileage":
GenericParameters.OrderBy = source => source.OrderBy(v => v.Mileage);
break;
case "mileage_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.Mileage);
break;
case "NextService":
GenericParameters.OrderBy = source => source.OrderBy(v => v.NextService);
break;
case "nextService_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.NextService);
break;
case "Employee":
GenericParameters.OrderBy = source => source.OrderBy(v => v.Employee.Name);
break;
case "employee_desc":
GenericParameters.OrderBy = source => source.OrderByDescending(v => v.Employee.Name);
break;
default:
GenericParameters.OrderBy = source => source.OrderBy(v => v.ID);
break;
}
#endregion
GenericParameters.Skip = (GenericParameters.PageNumber - 1) * GenericParameters.PageSize;
GenericParameters.Take = GenericParameters.PageSize;
}
var vehicleList = (Mapper.Map <List <IVehicle> >(await Repository.GetAllAsync(GenericParameters)));
return(vehicleList);
}
public VehicleRepository(IGenericRepository repository, IGenericRepositoryParameters <VehicleEntity> parameters)
{
this.Repository = repository;
this.GenericParameters = parameters;
}
public MeasuringDeviceRepository(IGenericRepository repository, IGenericRepositoryParameters <MeasuringDeviceEntity> parameters)
{
this.Repository = repository;
this.GenericParameters = parameters;
}
