public async Task <PopularResult <string> > GenerateTokenAsync(string uid, string pwd)
{
var result = new PopularResult <string>();
if (string.IsNullOrEmpty(uid) || string.IsNullOrEmpty(pwd))
{
result.Failed("用户名或密码为空");
return(result);
}
var claims = new[] {
new Claim(ClaimTypes.Name, "admin"),
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim(ClaimTypes.Role, "super"),
new Claim(JwtRegisteredClaimNames.Exp, $"{new DateTimeOffset(DateTime.Now.AddMinutes(AppSettings.JWT.Expires)).ToUnixTimeSeconds()}"),
new Claim(JwtRegisteredClaimNames.Nbf, $"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}")
};
var key = new SymmetricSecurityKey(AppSettings.JWT.SecurityKey.GetBytes());
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var securityToken = new JwtSecurityToken(
issuer: AppSettings.JWT.Domain,
audience: AppSettings.JWT.Domain,
claims: claims,
expires: DateTime.Now.AddMinutes(AppSettings.JWT.Expires),
signingCredentials: creds);
var token = new JwtSecurityTokenHandler().WriteToken(securityToken);
result.Success(token);
return(await Task.FromResult(result));
}
public async Task <PopularResult <string> > PostAsync()
{
var result = new PopularResult <string>();
result.Success();
return(await Task.FromResult(result));
}
public async Task <PopularResult> DeleteAsync(int id)
{
var result = new PopularResult();
await _maintenanceRepository.DeleteAsync(id);
return(result);
}
public async Task <PopularResult <List <VeComStaDto> > > GetVeComStaAsync(VeComStaQueryDto dto)
{
var result = new PopularResult <List <VeComStaDto> >();
var oilCostQuery = _oilCostRepoitory.Where(x => x.RefuelingTime >= dto.StartTime && x.RefuelingTime <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, OilCost = x.Sum(i => i.Expend) });
var mileageQuery = _vehicleMileageRepository.Where(x => x.RecordDate >= dto.StartTime && x.RecordDate <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, Mileage = (x.Max(i => i.Mileage) - x.Min(i => i.Mileage)) });
var maintenanceExpendQuery = _maintenanceRepository.Where(x => x.RecordTime >= dto.StartTime && x.RecordTime <= dto.EndTime).GroupBy(x => x.VehicleId).Select(x => new { VeId = x.Key, maintenanceExpend = x.Sum(i => i.Expend) });
var all = from v in _vehicleRepository.Where(x => x.IsDelete == 0).WhereIf(dto.UnitId.HasValue, x => x.UnitId == dto.UnitId.Value)
join oil in oilCostQuery on v.Id equals oil.VeId into voil
from newvoil in voil.DefaultIfEmpty()
join mil in mileageQuery on v.Id equals mil.VeId into vmil
from newvmil in vmil.DefaultIfEmpty()
join mai in maintenanceExpendQuery on v.Id equals mai.VeId into vmai
from newvmai in vmai.DefaultIfEmpty()
select new VeComStaDto()
{
License = v.License,
OilCost = newvoil.OilCost,
Mileage = newvmil.Mileage,
Maintenance = newvmai.maintenanceExpend
};
var list = await AsyncExecuter.ToListAsync(all);
result.Success(list);
return(result);
}
public async Task <PopularResult> DeleteAsync(int id)
{
var result = new PopularResult();
await _violationRepository.DeleteAsync(id);
return(result);
}
public async Task <PopularResult> DeleteAsync(int id)
{
var result = new PopularResult();
await _vehicleMileageRepository.DeleteAsync(id);
return(result);
}
public async Task <PopularResult <PagedResultDto <ViolationDto> > > GetListAsync(ViolationQueryDto dto)
{
var result = new PopularResult <PagedResultDto <ViolationDto> >();
var countQuery = _violationRepository.Where(x => x.IsDelete == dto.IsDelete)
.WhereIf(!dto.License.IsNullOrWhiteSpace(), violation => violation.Vehicle.License.Contains(dto.License));
var query = from m in countQuery.OrderBy(x => x.CreateTime).PageBy(dto.ToSkipCount(), dto.ToMaxResultCount())
join v in _vehicleRepository on m.VehicleId equals v.Id into cls
from c in cls.DefaultIfEmpty()
select new ViolationEntity(m.Id)
{
Fine = m.Fine,
Indemnity = m.Indemnity,
IsOutDanger = m.IsOutDanger,
TookDate = m.TookDate,
MaintenanceCost = m.MaintenanceCost,
Vehicle = c,
VehicleId = m.VehicleId,
//IsDelete = m.IsDelete,
CreateTime = m.CreateTime,
Creator = m.Creator,
Remark = m.Remark,
};
var violations = await AsyncExecuter.ToListAsync(query);
var totalCount = await AsyncExecuter.CountAsync(countQuery);
var dtos = ObjectMapper.Map <List <ViolationEntity>, List <ViolationDto> >(violations);
result.Success(new PagedResultDto <ViolationDto>(totalCount, dtos));
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(VehicleDto dto)
{
var result = new PopularResult <string>();
var vehicle = ObjectMapper.Map <VehicleDto, VehicleEntity>(dto);
await _vehicleRepository.UpdateAsync(vehicle);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(InsuranceDto dto)
{
var result = new PopularResult <string>();
var insurance = ObjectMapper.Map <InsuranceDto, InsuranceEntity>(dto);
await _insuranceRepository.UpdateAsync(insurance);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(DictDto dto)
{
var result = new PopularResult <string>();
var dict = ObjectMapper.Map <DictDto, DictEntity>(dto);
await _dictRepository.UpdateAsync(dict);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(UnitDto dto)
{
var result = new PopularResult <string>();
var unit = ObjectMapper.Map <UnitDto, UnitEntity>(dto);
await _unitRepository.UpdateAsync(unit);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(ViolationDto dto)
{
var result = new PopularResult <string>();
dto.Vehicle = null;
var violation = ObjectMapper.Map <ViolationDto, ViolationEntity>(dto);
await _violationRepository.UpdateAsync(violation);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(DictTypeDto dto)
{
var result = new PopularResult <string>();
var dictType = ObjectMapper.Map <DictTypeDto, DictTypeEntity>(dto);
await _dictRepository.DeleteAsync(x => x.DictTypeId == dto.Id);
await _dictTypeRepository.UpdateAsync(dictType);
result.Success("更新成功");
return(result);
}
/// <summary>
/// 异常处理
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public void OnException(ExceptionContext context)
{
// 错误日志记录
var result = new PopularResult()
{
Code = PopularResultCodeEnum.Failed,
Message = context.Exception.InnerException == null ? context.Exception.Message : context.Exception.InnerException.Message
};
context.Result = new JsonResult(result);
}
public async Task <PopularResult <string> > UpdateAsync(MaintenanceDto dto)
{
var result = new PopularResult <string>();
dto.Vehicle = null;
var maintenance = ObjectMapper.Map <MaintenanceDto, MaintenanceEntity>(dto);
await _maintenanceRepository.UpdateAsync(maintenance);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(DriverDto dto)
{
var result = new PopularResult <string>();
dto.Unit = null;
var driver = ObjectMapper.Map <DriverDto, DriverEntity>(dto);
await _driverRepository.UpdateAsync(driver);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <string> > UpdateAsync(OilCostDto dto)
{
var result = new PopularResult <string>();
dto.Vehicle = null;
dto.OilType = null;
var oilCost = ObjectMapper.Map <OilCostDto, OilCostEntity>(dto);
await _oilCostRepository.UpdateAsync(oilCost);
result.Success("更新成功");
return(result);
}
public async Task <PopularResult <PagedResultDto <DriverDto> > > GetListAsync(DriverQueryDto dto)
{
var result = new PopularResult <PagedResultDto <DriverDto> >();
var queryable = _driverRepository.Where(x => x.IsDelete == dto.IsDelete)
.WhereIf(!dto.Name.IsNullOrWhiteSpace(), driver => driver.Name.Contains(dto.Name))
.WhereIf(!dto.Name.IsNullOrWhiteSpace(), driver => driver.Name.Contains(dto.Name))
.WhereIf(dto.UnitId.HasValue, driver => driver.UnitId.Equals(dto.UnitId));
var query = from v in queryable.PageBy(dto.SkipCount, dto.MaxResultCount)
join
u in _unitRepository.WhereIf(dto.UnitId.HasValue, unit => unit.Id == dto.UnitId)
on v.UnitId equals u.Id
into cls
from c in cls.DefaultIfEmpty()
join d in _dictRepository.Where(x => true) on v.ClassId equals d.Id
into f
from e in f.DefaultIfEmpty()
join cc in _dictRepository.Where(x => true) on v.StatusId equals cc.Id
into ee
from ff in ee.DefaultIfEmpty()
select new DriverEntity(v.Id)
{
Address = v.Address,
ClassId = v.ClassId,
FirstIssueDate = v.FirstIssueDate,
Hiredate = v.Hiredate,
IdNo = v.IdNo,
Name = v.Name,
Sex = v.Sex,
StatusId = v.StatusId,
//IsDelete = v.IsDelete,
CreateTime = v.CreateTime,
Creator = v.Creator,
Remark = v.Remark,
UnitId = v.UnitId,
Unit = c,
Class = e,
Status = ff
};
var drivers = await AsyncExecuter.ToListAsync(query.PageBy(dto.SkipCount, dto.MaxResultCount));
var totalCount = await AsyncExecuter.CountAsync(queryable);
var dtos = ObjectMapper.Map <List <DriverEntity>, List <DriverDto> >(drivers);
result.Success(new PagedResultDto <DriverDto>(totalCount, dtos));
return(result);
}
public async Task <PopularResult <string> > InsertAsync(OilCostDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <OilCostDto, OilCostEntity>(dto);
var oilCost = await _oilCostRepository.InsertAsync(entity);
if (oilCost == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public async Task <PopularResult <string> > InsertAsync(InsuranceDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <InsuranceDto, InsuranceEntity>(dto);
var insurance = await _insuranceRepository.InsertAsync(entity);
if (insurance == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public async Task <PopularResult <string> > InsertAsync(VehicleMileageDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <VehicleMileageDto, VehicleMileageEntity>(dto);
var vehicleMileage = await _vehicleMileageRepository.InsertAsync(entity);
if (vehicleMileage == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public async Task <PopularResult <string> > InsertAsync(DictTypeDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <DictTypeDto, DictTypeEntity>(dto);
var dictType = await _dictTypeRepository.InsertAsync(entity);
if (dictType == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public async Task <PopularResult <string> > InsertAsync(ViolationDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <ViolationDto, ViolationEntity>(dto);
var violation = await _violationRepository.InsertAsync(entity);
if (violation == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public async Task <PopularResult> DeleteAsync(int id)
{
var result = new PopularResult();
var unit = await _unitRepository.GetAsync(id);
if (unit == null)
{
result.Failed("数据不存在");
return(result);
}
unit.Delete();
await _unitRepository.UpdateAsync(unit);
return(result);
}
public async Task <PopularResult> DeleteAsync(int id)
{
var result = new PopularResult();
var insurance = await _insuranceRepository.GetAsync(id);
if (insurance == null)
{
result.Failed("数据不存在");
return(result);
}
insurance.Delete();
await _insuranceRepository.UpdateAsync(insurance);
return(result);
}
public async Task <PopularResult <OilCostDto> > GetAsync(int id)
{
var result = new PopularResult <OilCostDto>();
var oilCost = await _oilCostRepository.GetAsync(id);
if (oilCost == null)
{
result.Failed("数据不存在");
return(result);
}
var dto = ObjectMapper.Map <OilCostEntity, OilCostDto>(oilCost);
result.Success(dto);
return(result);
}
public async Task <PopularResult <ViolationDto> > GetAsync(int id)
{
var result = new PopularResult <ViolationDto>();
var violation = await _violationRepository.GetAsync(id);
if (violation == null)
{
result.Failed("数据不存在");
return(result);
}
var dto = ObjectMapper.Map <ViolationEntity, ViolationDto>(violation);
result.Success(dto);
return(result);
}
public async Task <PopularResult <List <VehicleDto> > > GetAllAsync()
{
var result = new PopularResult <List <VehicleDto> >();
var vehicle = await AsyncExecuter.ToListAsync(_vehicleRepository.Where(x => x.IsDelete == 0));
if (vehicle == null)
{
result.Failed("数据不存在");
return(result);
}
var dtos = ObjectMapper.Map <List <VehicleEntity>, List <VehicleDto> >(vehicle);
result.Success(dtos);
return(result);
}
public async Task <PopularResult <List <InsuranceDto> > > GetAllAsync()
{
var result = new PopularResult <List <InsuranceDto> >();
var insurances = await _insuranceRepository.GetListAsync();
if (insurances == null)
{
result.Failed("数据不存在");
return(result);
}
var dtos = ObjectMapper.Map <List <InsuranceEntity>, List <InsuranceDto> >(insurances);
result.Success(dtos);
return(result);
}
public async Task <PopularResult <InsuranceDto> > GetAsync(int id)
{
var result = new PopularResult <InsuranceDto>();
var insurance = await _insuranceRepository.GetAsync(id);
if (insurance == null)
{
result.Failed("数据不存在");
return(result);
}
var dto = ObjectMapper.Map <InsuranceEntity, InsuranceDto>(insurance);
result.Success(dto);
return(result);
}
