public virtual async Task SetTokenAsync(TUser user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
ThrowIfDisposed();
Guard.ArgumentNotNull(user, nameof(user));
Guard.ArgumentNullOrWhiteSpaceString(loginProvider, nameof(loginProvider));
Guard.ArgumentNullOrWhiteSpaceString(name, nameof(name));
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(UserToken.UserId), user.Id);
filter.AddEqual(nameof(UserToken.LoginProvider), loginProvider);
filter.AddEqual(nameof(UserToken.Name), name);
var token = await _userTokenRepository.QueryFirstOrDefaultAsync(filter);
if (token == null)
{
UserToken newToken = new UserToken();
newToken.Id = _idGenerationService.GenerateId();
newToken.Name = name;
newToken.Value = value;
newToken.UserId = user.Id;
await _userTokenRepository.InsertAsync(newToken);
}
else
{
token.Value = value;
await _userTokenRepository.UpdateAsync(token);
}
}
private void QueryCollect()
{
ClearDapperCompisiteKeyEntity();
var d1 = CreateDapperCompisiteKeyEntity();
var d2 = CreateDapperCompisiteKeyEntity(2, 2);
var d3 = CreateDapperCompisiteKeyEntity(3, 3);
try
{
var dapperInstance = _dapper;
SingleQueryFilter filter = new SingleQueryFilter().AddGreater("products_id", 1).AddLess("products_id", 3);
var dapperQueryResult = dapperInstance.Query(filter);
CompareHelper.Compare(d2, dapperQueryResult.Where(s => s.products_id == 2).FirstOrDefault());
Assert.Equal(dapperQueryResult.Count(), 1);
SingleQueryFilter filter2 = new SingleQueryFilter().AddEqual("products_id", 1);
var comFilter1 = QueryFilter.CombineOr(filter, filter2);
dapperQueryResult = dapperInstance.Query(comFilter1);
CompareHelper.Compare(d2, dapperQueryResult.Where(s => s.products_id == 2).FirstOrDefault());
CompareHelper.Compare(d1, dapperQueryResult.Where(s => s.products_id == 1).FirstOrDefault());
Assert.Equal(dapperQueryResult.Count(), 2);
}
finally
{
ClearDapperCompisiteKeyEntity();
}
}
public virtual async Task <IList <TUser> > GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)
{
ThrowIfDisposed();
Guard.ArgumentNotNull(claim, nameof(claim));
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(UserClaim.ClaimValue), claim.Value);
filter.AddEqual(nameof(UserClaim.ClaimType), claim.Type);
var userClaim = await _userClaimRepository.QueryFirstOrDefaultAsync(filter);
if (userClaim != null)
{
SingleQueryFilter userFilter = new SingleQueryFilter();
userFilter.AddEqual(nameof(UserBase.Id), userClaim.UserId);
var user = await _userRepository.QueryFirstOrDefaultAsync(userFilter);
return(user == null ? new List <TUser>() : new List <TUser>()
{
user
});
}
return(new List <TUser>());
}
/// <summary>
/// <see cref="IMyTestRepository.GetByName"/>
/// </summary>
public async Task <MyTest> GetByName(string name)
{
SingleQueryFilter query = new SingleQueryFilter();
query.AddEqual(nameof(MyTest.Name), name);
return(await QueryFirstOrDefaultAsync(query));
}
private void Query()
{
ClearDapperTestEntity();
var d1 = CreateDapperTestEntity();
var d2 = CreateDapperTestEntity(2);
var d3 = CreateDapperTestEntity(3);
try
{
var dapperInstance = _dapper;
var filter = new SingleQueryFilter().AddEqual(nameof(DapperTestEntity.dec_value), 1);
var result = dapperInstance.Query(filter);
helper.ExecuteReader("select * from dapper_all_test where id=1", reader =>
{
while (reader.Read())
{
CompareHelper.Compare(reader, result.Where(x => x.id == Convert.ToInt32(reader["id"])).FirstOrDefault());
}
});
}
finally
{
ClearDapperTestEntity();
}
}
/// <summary>
/// 访问Lambda表达式所有运算符（从句、二元运算符）
/// </summary>
/// <param name="node">节点</param>
/// <returns></returns>
protected override Expression VisitBinary(BinaryExpression node)
{
// 遇到从句将两边条件合并
BooleanClause clause;
if (ClauseMapping.TryGetValue(node.NodeType, out clause))
{
var leftVisitor = new SimpleVisitor();
leftVisitor.Visit(node.Left);
var rightVisitor = new SimpleVisitor();
rightVisitor.Visit(node.Right);
_filter = new CombinedQueryFilter(leftVisitor._filter, rightVisitor._filter, clause);
return(node);
}
// 遇到二元运算符则将运算逻辑拆分为独立条件
BinaryOperation symbol;
if (OperationMapping.TryGetValue(node.NodeType, out symbol))
{
var leftVisitor = new SimpleVisitor();
leftVisitor.Visit(node.Left);
var rightVisitor = new SimpleVisitor();
rightVisitor.Visit(node.Right);
var x = new SingleQueryFilter();
x.AddPredicate(leftVisitor._fieldName, symbol, rightVisitor._value);
_filter = x;
return(node);
}
throw new NotSupportedException($"不支将 Lambda 表达式解析为 {nameof(QueryFilter)}，请确保右侧的表达式是一个符合规范的二元表达式。");
}
private void QueryAsync()
{
ClearTestEntity();
var d1 = CreateTestEntity();
var d2 = CreateTestEntity(2);
var d3 = CreateTestEntity(3);
try
{
var dapperInstance = _dapper;
var filter = new SingleQueryFilter().AddEqual(nameof(DapperAllTest.DecValue), 1);
var result = dapperInstance.QueryAsync(filter).GetAwaiter().GetResult();
helper.ExecuteReader("select * from DapperAllTest where id=1", reader =>
{
while (reader.Read())
{
CompareHelper.ComparePascalCase(reader, result.Where(x => x.Id == Convert.ToInt32(reader["Id"])).FirstOrDefault());
}
});
}
finally
{
ClearTestEntity();
}
}
public virtual async Task RemoveFromRoleAsync(TUser user, string roleName, CancellationToken cancellationToken)
{
ThrowIfDisposed();
Guard.ArgumentNotNull(user, nameof(user));
Guard.ArgumentNullOrWhiteSpaceString(roleName, nameof(roleName));
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(RoleBase.Name), roleName);
var role = await _roleRepository.QueryFirstOrDefaultAsync(filter);
if (role == null)
{
throw new InvalidOperationException($"找不到名称 {roleName} 的角色（Role）。");
}
SingleQueryFilter userRoleFilter = new SingleQueryFilter();
userRoleFilter.AddEqual(nameof(UserRole.UserId), user.Id);
userRoleFilter.AddEqual(nameof(UserRole.RoleId), role.Id);
var userRole = await _userRoleRepository.QueryFirstOrDefaultAsync(userRoleFilter);
if (userRole != null)
{
await _userRoleRepository.DeleteAsync(userRole);
}
}
/// <summary>
/// 通过TokenBrandId删除注册明细
/// </summary>
/// <param name="tokenBrandId"></param>
/// <returns></returns>
public async Task <int> DeleteByTokenBrandIdAsync(long tokenBrandId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrandDetail.TokenBrandId), tokenBrandId);
return(await _repository.DeleteAsync(filter));
}
/// <summary>
/// 获取消息中心，多少个消息类型，就有多少条
/// </summary>
/// <param name="userId"></param>
/// <param name="appId"></param>
/// <returns></returns>
public async Task <IList <PushMessageTypeDomainModel> > GetPushMessageListGroupByMessageTypeAsync(long userId, int appId)
{
Guard.ArgumentCondition(userId > 0, $"{nameof(userId)}参数不合法");
Guard.ArgumentCondition(appId > 0, $"{nameof(appId)}参数不合法");
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushMessage.UserId), userId);
filter.AddEqual(nameof(PushMessage.AppId), appId);
filter.AddNotEqual(nameof(PushMessage.State), (int)ReadState.Clear);
var list = await _pushMessageRepository.QueryAsync(filter);
if (list == null)
{
return(null);
}
IEnumerable <int> messageTypeList = list.Select(t => t.MessageType).Distinct().ToList();
if (messageTypeList == null)
{
return(null);
}
IList <PushMessageTypeDomainModel> typeList = new List <PushMessageTypeDomainModel>();
foreach (var item in messageTypeList)
{
var pushMessage = list.Where(t => t.MessageType == item).OrderByDescending(t => t.CreateAt).FirstOrDefault();
PushMessageTypeDomainModel model = new PushMessageTypeDomainModel {
Message = pushMessage.Msg, MessageType = item
};
typeList.Add(model);
}
return(typeList.OrderBy(t => t.MessageType).ToList());
}
public async Task <int> DeleteProcessByIdAsync(long id)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushSendProcess.Id), id);
return(await _repository.DeleteAsync(filter));
}
private void Parameter(string name)
{
var where = LamdaQueryParser.Where <User>(u => u.Name == name) as SingleQueryFilter;
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(User.Name), name);
Compare(where, filter);
}
/// <summary>
/// 获取设备的Token
/// </summary>
/// <param name="tokenBrandId"></param>
/// <param name="channelId"></param>
/// <returns></returns>
public async Task <PushTokenBrandDetail> GetDeviceTokenAsync(long tokenBrandId, long channelId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrandDetail.TokenBrandId), tokenBrandId);
filter.AddEqual(nameof(PushTokenBrandDetail.ChannelId), channelId);
return(await _repository.QueryFirstOrDefaultAsync(filter));
}
private async Task <PushTokenBrand> GetTokenBrandAsync(string token, string appId, string deviceId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrand.Token), token);
filter.AddEqual(nameof(PushTokenBrand.AppId), appId);
filter.AddEqual(nameof(PushTokenBrand.DeviceId), deviceId);
return(await _repository.QueryFirstOrDefaultAsync(filter));
}
/// <summary>
/// <see cref="IMyTestRepository.GetByName"/>
/// </summary>
public async Task <MyTestResponse> GetByName(string name)
{
SingleQueryFilter query = new SingleQueryFilter();
query.AddEqual(nameof(MyTest.Name), name);
MyTest result = await QueryFirstOrDefaultAsync(query);
return(_mapper.Map <MyTestResponse>(result));
}
public virtual async Task <TRole> FindByNameAsync(string normalizedRoleName, CancellationToken cancellationToken)
{
ThrowIfDisposed();
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(RoleBase.NormalizedName), normalizedRoleName);
return(await _roleRepository.QueryFirstOrDefaultAsync(filter));
}
public async Task <PushSendProcessDomainModel> GetProcessByIdAsync(long processId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushSendProcess.Id), processId);
PushSendProcess entity = await _repository.QueryFirstOrDefaultAsync(filter);
return(_mapper.Map <PushSendProcessDomainModel>(entity));
}
public async Task <List <long> > SelectProcessIdListByBatchNOAsync(Guid guid)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushSendProcess.BatchNo), guid);
var res = await _repository.QueryAsync(filter);
return(res?.Select(i => i.Id).ToList());
}
/// <summary>
/// 根据id获取推送通道
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <PushChannelDomainModel> GetChannelByIdAsync(long id)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushChannel.Id), id);
var entity = await _repository.QueryFirstOrDefaultAsync(filter);
return(_mapper.Map <PushChannelDomainModel>(entity));
}
public async Task <int> GetSendFailureCountAsync(DateTime beginTime, DateTime endTime)
{
var filter = new SingleQueryFilter();
filter.AddGreaterOrEqual(nameof(PushProcessHistory.SendTime), beginTime);
filter.AddLessOrEqual(nameof(PushProcessHistory.SendTime), endTime);
return(await _repository.CountAsync(filter));
}
/// <summary>
/// 通过TokenBrandId获取明细列表
/// </summary>
/// <param name="tokenBrandId"></param>
/// <returns></returns>
public async Task <List <PushTokenBrandDetail> > GetDeviceTokenListAsync(long tokenBrandId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrandDetail.TokenBrandId), tokenBrandId);
var res = await _repository.QueryAsync(filter);
return(res.ToList());
}
/// <summary>
/// 通过key获取配置
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task <PushConfigDomainModel> GetConfigByKeyAsync(string key)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushConfig.ConfigKey), key);
PushConfig entity = await _repository.QueryFirstOrDefaultAsync(filter);
return(_mapper.Map <PushConfigDomainModel>(entity));
}
private void Compare(SingleQueryFilter s1, SingleQueryFilter s2)
{
Assert.Equal(s1.Count(), s2.Count());
s1.ForEach(t =>
{
var count = s2.Where(s => s.FieldName == t.FieldName && (int)s.Operation == (int)t.Operation &&
s.OperationValue.ToString() == t.OperationValue.ToString()).Count();
Assert.Equal(count, 1);
});
}
/// <summary>
/// 取推送App的通道
/// </summary>
/// <param name="appId">app编号</param>
/// <param name="systemType">系统类型（0：IOS 1:Android）</param>
/// <param name="channelId">推送通道编号</param>
/// <returns></returns>
public async Task <PushAppChannelDomainModel> GetAppChannelByAppInfoAsync(int appId, int systemType, long channelId)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushAppChannel.AppId), appId);
filter.AddEqual(nameof(PushAppChannel.SystemType), systemType);
filter.AddEqual(nameof(PushAppChannel.ChannelId), channelId);
PushAppChannel entity = await _repository.QueryFirstOrDefaultAsync(filter);
return(_mapper.Map <PushAppChannelDomainModel>(entity));
}
public async Task <List <PushSendProcessDomainModel> > GetProcessListByBatchNOAsync(string batchNO)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushSendProcess.BatchNo), batchNO);
var res = await _repository.QueryAsync(filter);
List <PushSendProcess> list = res.ToList();
return(_mapper.Map <List <PushSendProcessDomainModel> >(list));
}
/// <summary>
/// 获取通过Token获取注册列表
/// </summary>
/// <param name="RzToken"></param>
/// <returns></returns>
public async Task <List <PushTokenBrandDomainModel> > GetTokenBrandListByTokenAsync(string token)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrand.Token), token);
var res = await _repository.QueryAsync(filter);
List <PushTokenBrand> list = res.ToList();
return(_mapper.Map <List <PushTokenBrandDomainModel> >(list));
}
/// <summary>
/// 生产简单筛选
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="queryFilter">查询过滤器实例</param>
/// <param name="parameters">查询参数</param>
/// <returns></returns>
private string GenerateSingleFilter <TEntity>(SingleQueryFilter queryFilter, DynamicParameters parameters)
{
if (queryFilter.IsEmpty)
{
return(string.Empty);
}
string spliter = queryFilter.Clause == BooleanClause.Or ? " OR " : " AND ";
return(queryFilter.Select(p => GeneratePredicateFilter <TEntity>(p, parameters)).ToArrayString(spliter));
}
public virtual Task <TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
{
if (normalizedEmail.IsNullOrWhiteSpace())
{
return(null);
}
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(UserBase.Email), normalizedEmail);
return(_userRepository.QueryFirstOrDefaultAsync(filter));
}
/// <summary>
/// 根据id删除TokenBrand
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <int> DeleteTokenBrandByIdAsync(long id)
{
var filter = new SingleQueryFilter();
filter.AddEqual(nameof(PushTokenBrand.Id), id);
int deleteRow = await _repository.DeleteAsync(filter);
//删除注册详情表
int deleteDetailRows = await _pushTokenBrandDetailService.DeleteByTokenBrandIdAsync(id);
return(deleteRow + deleteDetailRows);
}
public virtual async Task <IList <Claim> > GetClaimsAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
Guard.ArgumentNotNull(role, nameof(role));
SingleQueryFilter filter = new SingleQueryFilter();
filter.AddEqual(nameof(RoleBase.Id), role.Id);
var roleClaims = await _roleClaimRepository.QueryAsync(filter);
return(roleClaims.Select(r => r.ToClaim()).ToArray());
}
