using EFCore.BulkExtensions;
|
using Furion.DatabaseAccessor;
|
using Furion.DistributedIDGenerator;
|
using Furion.FriendlyException;
|
using Mapster;
|
using Microsoft.EntityFrameworkCore;
|
using Microsoft.EntityFrameworkCore.Metadata.Internal;
|
using Microsoft.EntityFrameworkCore.Storage;
|
using System;
|
using System.Collections.Generic;
|
using System.Data.Common;
|
using System.Linq;
|
using System.Linq.Expressions;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace ApiTools.Core
|
{
|
public abstract class BaseRepository<TEntity, TDbContextLocator>
|
where TEntity : CommonEntity, new()
|
where TDbContextLocator : class, IDbContextLocator
|
{
|
public readonly IRepository<TEntity, TDbContextLocator> rep;
|
public readonly CurrentLogier logier;
|
|
public BaseRepository(
|
IRepository<TEntity, TDbContextLocator> rep)
|
{
|
this.rep = rep;
|
logier = JwtUtils.GetCurrentLogier();
|
}
|
|
public virtual IQueryable<TEntity> GetQueryableIgnoreFilter(bool noTracking = true)
|
{
|
return rep.GetQueryable(noTracking);
|
}
|
|
/// <summary>
|
/// 获取查询
|
/// </summary>
|
/// <param name="noTracking"></param>
|
/// <returns></returns>
|
public virtual IQueryable<TEntity> GetQueryable(bool noTracking = true)
|
{
|
return rep.GetQueryable(noTracking);
|
}
|
|
/// <summary>
|
/// 获取查询
|
/// </summary>
|
/// <param name="noTracking"></param>
|
/// <param name="query"></param>
|
/// <returns></returns>
|
public virtual IQueryable<TEntity> GetQueryable(
|
bool noTracking,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query)
|
{
|
var q = GetQueryable(false);
|
if (query != null)
|
{
|
q = query(q);
|
}
|
return q;
|
}
|
|
/// <summary>
|
/// 获取实体
|
/// </summary>
|
/// <param name="id"></param>
|
/// <param name="query"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public virtual Task<TEntity> Get(
|
Guid id,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
return GetQueryable(false, query)
|
.Where(it => it.Id == id)
|
.FirstOrDefaultAsync(cancellationToken);
|
}
|
|
/// <summary>
|
/// 获取实体
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="query"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public virtual Task<List<TEntity>> Get(
|
List<Guid> ids,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
return GetQueryable(false, query)
|
.Where(it => ids.Contains(it.Id))
|
.ToListAsync(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询选择器数据
|
/// </summary>
|
/// <typeparam name="TValue"></typeparam>
|
/// <typeparam name="TData"></typeparam>
|
/// <param name="request"></param>
|
/// <param name="getValue"></param>
|
/// <param name="getLabel"></param>
|
/// <param name="query"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<List<SelectOption<TValue, TData>>> GetSelect<TValue, TData>(
|
SelectQuery<TValue, TData> request,
|
Func<TData, TValue> getValue,
|
Func<TData, string> getLabel,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
var q = GetQueryable();
|
if (query != null) q = query(q);
|
else q = q.OrderBy(it => it.Sort).ThenBy(it => it.CreatedTime);
|
var models = await q
|
.ProjectToType<TData>()
|
.ToListAsync(cancellationToken);
|
var options = new List<SelectOption<TValue, TData>>();
|
foreach (var model in models)
|
{
|
var option = new SelectOption<TValue, TData>();
|
option.Data = model;
|
option.Value = getValue(model);
|
option.Label = getLabel(model);
|
options.Add(option);
|
}
|
return options;
|
}
|
|
public async Task<TResult> GetDetail<TResult>(
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
var model = await GetQueryable(false, query)
|
.ProjectToType<TResult>()
|
.FirstOrDefaultAsync(cancellationToken);
|
if (model == null)
|
{
|
var summary = await typeof(TEntity).GetSummary();
|
throw Oops.Oh(EnumErrorCodeType.s404, $"{summary ?? "信息"}");
|
}
|
return model;
|
}
|
|
/// <summary>
|
/// 设置是否禁用
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="query"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<int> SetIsDisabled(
|
SetIsDisabledCommand request,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
var q = GetQueryable(false);
|
if (query != null) q = query(q);
|
var entities = await q
|
.Where(it => request.Ids.Contains(it.Id))
|
.ToListAsync();
|
var isDisabledProperty = typeof(TEntity).GetProperty("IsDisabled", typeof(bool));
|
foreach (var entity in entities)
|
{
|
isDisabledProperty.SetValue(entity, request.IsDisabled);
|
}
|
await UpdateAsync(entities);
|
return entities.Count;
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="query"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<int> DeleteData(
|
DeleteDataCommand request, Func<IQueryable<TEntity>,
|
IQueryable<TEntity>> query = null,
|
CancellationToken cancellationToken = default)
|
{
|
var q = GetQueryable(false);
|
if (query != null) q = query(q);
|
var entities = await q
|
.Where(it => request.Ids.Contains(it.Id))
|
.ToListAsync(cancellationToken);
|
return entities.Any()
|
? await rep.DeleteNowAsync(entities, cancellationToken)
|
: 0;
|
}
|
|
/// <summary>
|
/// 更新数据
|
/// </summary>
|
/// <typeparam name="TRequest"></typeparam>
|
/// <param name="q"></param>
|
/// <param name="request"></param>
|
/// <param name="update"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<Guid> UpdateData<TRequest>(
|
IQueryable<TEntity> q,
|
TRequest request,
|
Action<TEntity> update = null,
|
CancellationToken cancellationToken = default)
|
{
|
var entity = await q.FirstOrDefaultAsync();
|
if (entity == null)
|
{
|
var summary = await typeof(TEntity).GetSummary();
|
throw Oops.Oh(EnumErrorCodeType.s404, $"{summary ?? "信息"}");
|
}
|
|
if (update != null) update(entity);
|
else request.Adapt(entity);
|
await rep.UpdateAsync(entity);
|
return entity.Id;
|
}
|
|
/// <summary>
|
/// 保存数据
|
/// </summary>
|
/// <typeparam name="TRequest"></typeparam>
|
/// <param name="request"></param>
|
/// <param name="query"></param>
|
/// <param name="checkExist"></param>
|
/// <param name="update"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<TEntity> SaveData<TRequest>(
|
TRequest request,
|
Func<IQueryable<TEntity>, IQueryable<TEntity>> query = null,
|
Expression<Func<TEntity, bool>> checkExist = null,
|
Action<TEntity> update = null,
|
CancellationToken cancellationToken = default)
|
where TRequest : SaveDataCommand, new()
|
{
|
var xmlDoc = await XmlDocUtils.GetXmlDocAsync();
|
var summary = await typeof(TEntity).GetSummary(xmlDoc);
|
if (checkExist != null && await GetQueryableIgnoreFilter().AnyAsync(checkExist))
|
throw Oops.Oh(EnumErrorCodeType.s405, $"{summary ?? "信息"}");
|
if (request.Id.HasValue)
|
{
|
var q = GetQueryable(false);
|
if (query != null) q = query(q);
|
var entity = await q.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken);
|
if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, $"{summary ?? "信息"}");
|
if (update != null) update(entity);
|
else request.Adapt(entity);
|
await rep.UpdateAsync(entity);
|
return entity;
|
}
|
else
|
{
|
var entity = new TEntity();
|
if (update != null) update(entity);
|
else request.Adapt(entity);
|
await rep.InsertAsync(entity);
|
return entity;
|
}
|
}
|
|
public virtual Task<List<T1>> SqlQueriesAsync<T1>(string sql, object model, CancellationToken cancellationToken = default)
|
{
|
return rep.SqlQueriesAsync<T1>(sql, model, cancellationToken);
|
}
|
|
public virtual IDbContextTransaction BeginTransaction()
|
{
|
return rep.Database.BeginTransaction();
|
}
|
|
public virtual Task InsertAsync(TEntity entity, CancellationToken cancellationToken = default)
|
{
|
return rep.InsertAsync(entity, cancellationToken: cancellationToken);
|
}
|
|
public virtual Task InsertNowAsync(TEntity entity, CancellationToken cancellationToken = default)
|
{
|
return rep.InsertNowAsync(entity, cancellationToken: cancellationToken);
|
}
|
|
public virtual Task InsertAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
|
{
|
return rep.InsertAsync(entities, cancellationToken);
|
}
|
|
public virtual Task<int> InsertNowAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
|
{
|
return rep.InsertNowAsync(entities, cancellationToken);
|
}
|
|
public virtual async Task BulkInsertAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
|
{
|
await rep.Context.BulkInsertAsync(entities, cancellationToken: cancellationToken);
|
}
|
|
public virtual Task UpdateAsync(TEntity entity)
|
{
|
return rep.UpdateAsync(entity);
|
}
|
|
public virtual Task UpdateNowAsync(TEntity entity)
|
{
|
return rep.UpdateNowAsync(entity);
|
}
|
|
public virtual Task UpdateAsync(List<TEntity> entities)
|
{
|
return rep.UpdateAsync(entities);
|
}
|
|
public virtual Task<int> UpdateNowAsync(List<TEntity> entities)
|
{
|
return rep.UpdateNowAsync(entities);
|
}
|
|
public virtual Task DeleteAsync(TEntity entity)
|
{
|
return rep.DeleteAsync(entity);
|
}
|
|
public virtual Task DeleteNowAsync(TEntity entity, CancellationToken cancellationToken = default)
|
{
|
return rep.DeleteNowAsync(entity, cancellationToken);
|
}
|
|
public virtual Task DeleteAsync(List<TEntity> entities)
|
{
|
return rep.DeleteAsync(entities);
|
}
|
|
public virtual Task<int> DeleteNowAsync(List<TEntity> entities, CancellationToken cancellationToken = default)
|
{
|
return rep.DeleteNowAsync(entities, cancellationToken);
|
}
|
|
public virtual Task SaveNowAsync()
|
{
|
return rep.SaveNowAsync();
|
}
|
}
|
}
|
