public async Task DeleteAsync(TKey entityId)
{
TEntity entity = DbEntitySet.FirstOrDefault(p => p.Id.ToString().Equals(entityId.ToString()));
await DeleteAsync(entity);
await SaveChangesAsync();
}
public async Task CreateAsync(T entity, CancellationToken cancellationToken)
{
if (entity != null)
{
await DbEntitySet.AddAsync(entity, cancellationToken);
}
}
public void Delete(T entity)
{
if (entity != null)
{
DbEntitySet.Remove(entity);
}
}
public void Create(TEntity entity)
{
if (entity is ITimeTrail)
{
(entity as ITimeTrail).UtcCreatedDate = DateTime.UtcNow;
}
DbEntitySet.Add(entity);
}
public void RemoveRange(IEnumerable <TEntity> entities)
{
var ent = entities.ToArray();
for (int i = 0; i < ent.Length; i++)
{
DbEntitySet.Remove(ent[i]);
}
SaveChanges();
}
public void RemoveRange(IEnumerable <TEntity> entities)
{
var ent = entities.ToArray();
for (int i = 0; i < ent.Length; i++)
{
DbEntitySet.Remove(ent[i]);
DbContext.Entry <TEntity>((ent[i])).State = EntityState.Deleted;
}
SaveChanges();
}
public virtual IQueryable <TEntity> BuildQuery(Expression <Func <TEntity, bool> > filter = null, string includeProperties = "")
{
IQueryable <TEntity> query = DbEntitySet.AsNoTracking();
foreach (var include in includeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(include);
}
if (filter != null)
{
query = query.Where(filter);
}
return(query);
}
public virtual async Task <IdentityResult> AddClaimAsync(IdentityRole role, Claim claim, CancellationToken cancellationToken = default)
{
ThrowIfDisposed();
role.CheakArgument();
claim.CheakArgument();
var f2 = await DbEntitySet.AnyAsync(d => d.Id.Equals(role.Id));
if (f2)
{
var flag = await RoleClaims.AnyAsync(a => a.ClaimType.Equals(claim.Type) &&
a.ClaimValue.Equals(claim.Value) && a.RoleId.Equals(role.Id));
if (!flag)
{
RoleClaims.Add(CreateRoleClaim(role, claim));
return(await SaveChangesAsync(cancellationToken));
}
}
return(IdentityResult.Failed("已经存在该权限"));
}
public override async Task <IdentityResult> CreateAsync(IdentityPermission entity, CancellationToken cancellationToken)
{
bool flag = await DbEntitySet.AnyAsync(a => a.Controller.Equals(entity.Controller) && a.Action.Equals(entity.Action) && a.AreaName.Equals(entity.AreaName));
return(flag ? IdentityResult.Failed("已经有该记录") : await base.CreateAsync(entity, cancellationToken));
}
public void Delete(Group entity)
{
DbEntitySet.Remove(entity);
}
public virtual Group GetById(object id)
{
return(DbEntitySet.Find(id));
}
public virtual TEntity Find(params Object[] keyValues)
{
return(DbEntitySet.Find(keyValues));
}
public void Create(Group entity)
{
DbEntitySet.Add(entity);
}
/// <summary>
/// Mark an entity for deletion
/// </summary>
/// <param name="entity"></param>
public void Delete(TEntity entity)
{
DbEntitySet.Remove(entity);
}
public List <TEntity> GetAll()
{
return(DbEntitySet.ToList());
}
public TEntity GetFirst(Func <TEntity, bool> predicate)
{
return(DbEntitySet.First(predicate));
}
public IQueryable <TEntity> Include(string path)
{
return(DbEntitySet.Include(path));
}
public Task <bool> ContainsAsync(TEntity entity)
{
return(Task.Run(() => DbEntitySet.FirstOrDefault(p => p.Id.Equals(entity.Id)) != null));
}
public bool Any(Func <TEntity, bool> predicate)
{
return(DbEntitySet.Any(predicate));
}
public Task <TEntity> FindByIdAsync(TKey id)
{
return(DbEntitySet.FirstOrDefaultAsync(p => p.Id.ToString().Equals(id.ToString())));
}
public List <TEntity> GetWhere(Func <TEntity, bool> predicate)
{
return(DbEntitySet.Where(predicate).ToList());
}
public Task <List <TEntity> > GetWhereAsync(Func <TEntity, bool> predicate)
{
return(Task.Run(() => DbEntitySet.Where(predicate).ToList()));
}
public override async Task <IdentityResult> UpdateAsync(IdentityPermission entity, CancellationToken cancellationToken, params string[] propertys)
{
bool flag = await DbEntitySet.AnyAsync(a => !a.Id.Equals(entity.Id) && a.Controller.Equals(entity.Controller) && a.Action.Equals(entity.Action) && a.AreaName.Equals(entity.AreaName));
return(flag ? IdentityResult.Failed("已经有该记录") : await base.UpdateAsync(entity, cancellationToken, propertys));
}
public void Remove(TEntity entity)
{
DbEntitySet.Remove(entity);
SaveChanges();
}
/// <summary>
/// Insert an entity
/// </summary>
/// <param name="entity"></param>
public void Create(TEntity entity)
{
DbEntitySet.Add(entity);
}
public TEntity GetSingleOrDefault(Func <TEntity, bool> predicate)
{
return(DbEntitySet.SingleOrDefault(predicate));
}
/// <summary>
/// FindAsync an entity by ID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual Task <TEntity> GetByIdAsync(object id)
{
return(DbEntitySet.FindAsync(id));
}
public Task <List <TEntity> > GetAllAsync()
{
return(DbEntitySet.ToListAsync());
}
public virtual Task <Role> FindByNameAsync(string normalizedName, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
return(DbEntitySet.FirstOrDefaultAsync(r => r.NormalizedName == normalizedName, cancellationToken));
}
public virtual async Task <ApplicationGroups> GetByIdAsync(object id)
{
return(await DbEntitySet.FindAsync(new object[] { id }));
//return DbEntitySet.FindAsync(id);
}
