public UserClaimService(
IUserClaimRepository repository,
ICommandBus commandBus,
ILogger <UserClaimService> logger
) : base(repository, commandBus, logger)
{
}
public UserStoreTest()
{
_userRepository = A.Fake<IUserRepository>();
_userClaimRepository = A.Fake<IUserClaimRepository>();
_userClaimDtoMapper = A.Fake<IUserClaimDtoMapper>();
_userStore = new UserStore(_userRepository, _userClaimRepository, _userClaimDtoMapper);
}
public UserStore(IUserRepository userRepository, IRoleRepository roleRepository,
IUserRoleRepository userRoleRepository, IUserClaimRepository userClaimRepository)
{
_userRepository = userRepository;
_roleRepository = roleRepository;
_userRoleRepository = userRoleRepository;
_userClaimRepository = userClaimRepository;
}
public AuthenticationService(IAuthenticationRepository authenticationRepository, IUserClaimRepository userClaimRepository,
IUserLoginRepository userLoginRepository, IUserTokenRepository userTokenRepository)
{
_userTokenRepository = userTokenRepository;
_userLoginRepository = userLoginRepository;
_authenticationRepository = authenticationRepository;
_userClaimRepository = userClaimRepository;
}
private void resetRepositories()
{
_roleClaimRepository = null;
_roleRepository = null;
_userClaimRepository = null;
_userLoginRepository = null;
_userRepository = null;
_userTokenRepository = null;
}
public ApplicationUserStore(IUserRepository userRepository, IUserLoginRepository userLoginRepository,
IUserRoleRepository userRoleRepository, IUserClaimRepository userClaimRepository, IUserTokenRepository userTokenRepository)
{
_userRepository = userRepository;
_userLoginRepository = userLoginRepository;
_userRoleRepository = userRoleRepository;
_userClaimRepository = userClaimRepository;
_userTokenRepository = userTokenRepository;
}
public UserClaimService(IUserClaimRepository userClaimRepository, ILoginService loginService, IUserInfoRepository userInfoRepository,
IAgentRepository agentRepository, ICacheHelper cacheHelper, IUserClaimCache userClaimCache) : base(agentRepository, cacheHelper)
{
_userClaimRepository = userClaimRepository;
_userInfoRepository = userInfoRepository;
_loginService = loginService;
_agentRepository = agentRepository;
_userClaimCache = userClaimCache;
}
public UserRoleRepository(
IRepository <UserRole> repository,
UserContext context,
IUserClaimRepository userClaimRepository,
IApiIdentity apiIdentity) : base(context, apiIdentity)
{
_repository = repository;
//_context = context;
_userClaimRepository = userClaimRepository;
}
public UserService(UserManager <User> userManager, IUserRepository userRepository, IUserClaimRepository userClaimRepository,
IUserRoleRepository userRoleRepository, IRoleRepository roleRepository, IMapper mapper)
{
_mapper = mapper;
_userRepository = userRepository;
_userManager = userManager;
_userClaimRepository = userClaimRepository;
_userRoleRepository = userRoleRepository;
_roleRepository = roleRepository;
}
public GetBjdInfoService(IBaodanxinxiRepository baodanxinxiRepository, IBaodanXianZhongRepository baodanXianZhongRepository, IPreferentialActivityRepository preferentialActivityRepository, IBxBjUnionRepository bxBjUnionRepository, IUserClaimRepository userClaimRepository, ISaveQuoteRepository saveQuoteRepository, IMapBjdInfoRecord mapBjdInfoRecord, IGetBjdCheck getBjdCheck)
{
_preferentialActivityRepository = preferentialActivityRepository;
_bxBjUnionRepository = bxBjUnionRepository;
_userClaimRepository = userClaimRepository;
_saveQuoteRepository = saveQuoteRepository;
_mapBjdInfoRecord = mapBjdInfoRecord;
_getBjdCheck = getBjdCheck;
logErr = LogManager.GetLogger("ERROR");
}
public UserClaimsController(UserIdentityDbContext context,
IUserClaimRepository userClaimRepository,
IUnitOfWork <UserClaim> unitOfworkUserClaim,
IMapper mapper)
{
_userClaimRepository = userClaimRepository;
_unitOfworkUserClaim = unitOfworkUserClaim;
_mapper = mapper;
_cancellationToken = new CancellationToken();
_context = context;
}
public ClaimsPrincipalService(IUserScopeClaimRepository userScopeClaimRepository, IScopeClaimRepository scopeClaimRepository, IClaimRepository claimRepository,
IScopeRepository scopeRepository, IClaimsService claimService, IScopeService scopeService, IUserScopeRepository userScopeRepository, IUserClaimRepository userClaimRepository)
{
_userScopeClaimRepository = userScopeClaimRepository;
_scopeClaimRepository = scopeClaimRepository;
_claimRepository = claimRepository;
_scopeRepository = scopeRepository;
_claimService = claimService;
_scopeService = scopeService;
_userScopeRepository = userScopeRepository;
_userClaimRepository = userClaimRepository;
}
public AppIdentityUserManager(IUserStore<AppIdentityUser> store,
IOptions<IdentityOptions> optionsAccessor,
IPasswordHasher<AppIdentityUser> passwordHasher,
IEnumerable<IUserValidator<AppIdentityUser>> userValidators,
IEnumerable<IPasswordValidator<AppIdentityUser>> passwordValidators,
ILookupNormalizer keyNormalizer, AppIdentityErrorDescriber errors,
IServiceProvider services, ILogger<UserManager<AppIdentityUser>> logger,
IUserClaimRepository userClaimRepository)
: base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger)
{
_cancellationToken = services?.GetService<IHttpContextAccessor>()?.HttpContext?.RequestAborted ?? CancellationToken.None;
_userClaimRepository = userClaimRepository;
}
public ApplicationUserStoreFull(
IUserRepository userRepository,
IUserTokenRepository userTokenRepository,
IUserClaimRepository userClaimRepository,
IUserLoginRepository userLoginRepository,
IMapper mapper)
{
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
_userClaimRepository = userClaimRepository;
_userLoginRepository = userLoginRepository;
_mapper = mapper;
}
public UserStore(IUnitOfWork uow,
IUserRepository userRepository,
IUserLoginRepository userLoginRepository,
IUserClaimRepository userClaimRepository,
IUserRoleRepository userRoleRepository,
IRoleRepository roleRepository)
{
_uow = uow;
_userRepository = userRepository;
_userLoginRepository = userLoginRepository;
_userClaimRepository = userClaimRepository;
_userRoleRepository = userRoleRepository;
_roleRepository = roleRepository;
}
public UserStore(
ICurrentContextProvider contextProvider,
IRoleStore <TApplicationRole, int> roleStore,
IIdentityUserRepository <TUser> userRepository,
IUserRoleRepository <TUserRole> userRoleRepository,
IUserClaimRepository <TUserClaim> userClaimRepository)
{
this.contextProvider = contextProvider;
this.userRepository = userRepository;
this.roleStore = roleStore;
this.userRoleRepository = userRoleRepository;
this.userClaimRepository = userClaimRepository;
session = contextProvider.GetCurrentContext();
}
public AppIdentityUserStore(
AppIdentityErrorDescriber describer,
IUserManager userManager,
IUserRepository userRepository,
IUserClaimManager userClaimManager,
IUserClaimRepository userClaimRepository,
IMapper mapper)
: base(describer)
{
_userManager = userManager;
_userRepository = userRepository;
_userClaimManager = userClaimManager;
_userClaimRepository = userClaimRepository;
_mapper = mapper;
}
public UserStore(
ICurrentContextProvider contextProvider,
IRoleStore <TRole> roleStore,
IIdentityUserRepository <TUser> userRepository,
IUserRoleRepository <TUserRole> userRoleRepository,
IUserClaimRepository <TUserClaim> userClaimRepository
)
{
session = contextProvider.GetCurrentContext();
this.userRepository = userRepository;
this.roleStore = roleStore;
this.userRoleRepository = userRoleRepository;
this.userClaimRepository = userClaimRepository;
}
public int RemoveClaims(User user, IEnumerable <UserClaim> claims)
{
IUserClaimRepository uc_repo = _data_repository_factory.GetIdentityDataRepository <IUserClaimRepository>();
foreach (var uc in claims)
{
UserClaimData ucd = new UserClaimData()
{
UserID = user.UserId, Id = uc.ClaimID, ClaimType = uc.ClaimType, ClaimValue = uc.ClaimValue
};
uc_repo.Delete(ucd);
}
return(1);
}
public IList <UserClaim> GetClaims(User user)
{
IUserClaimRepository uc_repo = _data_repository_factory.GetIdentityDataRepository <IUserClaimRepository>();
List <UserClaim> ucs = new List <UserClaim>();
var claims = uc_repo.GetAll(user.UserId);
foreach (var ucd in claims)
{
ucs.Add(new UserClaim()
{
UserID = ucd.UserID, ClaimID = ucd.Id, ClaimType = ucd.ClaimType, ClaimValue = ucd.ClaimValue
});
}
return(ucs);
}
public void Dispose()
{
_users = null;
_userClaims = null;
_histories = null;
_activities = null;
_posts = null;
_attachments = null;
_customers = null;
_jobcards = null;
_healthChecks = null;
_healthCheckDetails = null;
_branches = null;
_appLogs = null;
_context.Dispose();
}
public virtual void Dispose(bool disposing)
{
if (!_disposed && _uow != null)
{
if (disposing)
{
_uow = null;
_userRepository = null;
_userLoginRepository = null;
_userClaimRepository = null;
_userRoleRepository = null;
_roleRepository = null;
}
_disposed = true;
}
}
public int ReplaceClaim(User user, UserClaim claim, UserClaim newClaim)
{
IUserClaimRepository uc_repo = _data_repository_factory.GetIdentityDataRepository <IUserClaimRepository>();
UserClaimData rem_ucd = new UserClaimData()
{
UserID = user.UserId, Id = claim.ClaimID,
ClaimType = claim.ClaimType, ClaimValue = claim.ClaimValue
};
uc_repo.Delete(rem_ucd);
UserClaimData new_ucd = new UserClaimData()
{
UserID = user.UserId, Id = newClaim.ClaimID,
ClaimType = newClaim.ClaimType, ClaimValue = newClaim.ClaimValue
};
return(uc_repo.Save(new_ucd));
}
public CustomUserManager(IUserStore <User> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <User> > logger, IUserClaimRepository userClaimRepository, IRoleRepository roleRepository,
IUserRoleRepository userRoleRepository, IUserRepository userRepository)
: base(store, optionsAccessor, passwordHasher,
userValidators, passwordValidators, keyNormalizer,
errors, services, logger)
{
_userClaimRepository = userClaimRepository;
_roleRepository = roleRepository;
_userRoleRepository = userRoleRepository;
_userRepository = userRepository;
}
public void GetBjdInfo_ThrowExecption_ReturnNegavite()
{
#region 配置 Substitute
IBaodanxinxiRepository _baodanxinxiRepository = Substitute.For <IBaodanxinxiRepository>();
IBaodanXianZhongRepository _baodanXianZhongRepository = Substitute.For <IBaodanXianZhongRepository>();
IPreferentialActivityRepository _preferentialActivityRepository = Substitute.For <IPreferentialActivityRepository>();
IBxBjUnionRepository _bxBjUnionRepository = Substitute.For <IBxBjUnionRepository>();
IUserClaimRepository _userClaimRepository = Substitute.For <IUserClaimRepository>();
ISaveQuoteRepository _saveQuoteRepository = Substitute.For <ISaveQuoteRepository>();
IMapBjdInfoRecord _mapBjdInfoRecord = Substitute.For <IMapBjdInfoRecord>();
IGetBjdCheck _getBjdCheck = Substitute.For <IGetBjdCheck>();
var bjdItemRequest = Arg.Any <GetBjdItemRequest>();
_baodanxinxiRepository.When(x => x.Find(Arg.Any <int>())).Do(info =>
{
throw new Exception();
});
GetBjdInfoService getBjdInfoService = new GetBjdInfoService(_baodanxinxiRepository, _baodanXianZhongRepository, _preferentialActivityRepository,
_bxBjUnionRepository, _userClaimRepository, _saveQuoteRepository, _mapBjdInfoRecord, _getBjdCheck);
#endregion
#region 操作 Arg
var result = getBjdInfoService.GetBjdInfo(bjdItemRequest, null);
#endregion
#region 断言 Assert
Assert.AreEqual(-1, result.BusinessStatus);
#endregion
}
public GetUserClaimQueryHandler(IUserClaimRepository userClaimDal)
{
_userClaimDal = userClaimDal;
}
public CreateUserClaimsInternalCommandHandler(IUserClaimRepository userClaimsRepository)
{
_userClaimsRepository = userClaimsRepository;
}
public CreateUserClaimCommandHandler(IUserClaimRepository userClaimDal)
{
_userClaimDal = userClaimDal;
}
public SetClaimsService(IUserClaimRepository userClaimRepository)
{
_userClaimRepository = userClaimRepository;
logErr = LogManager.GetLogger("ERROR");
}
public GetUserClaimLookupByUserIdQueryHandler(IUserClaimRepository userClaimRepository, IMediator mediator)
{
_userClaimRepository = userClaimRepository;
_mediator = mediator;
}
public DeleteUserClaimCommandHandler(IUserClaimRepository userClaimRepository)
{
_userClaimRepository = userClaimRepository;
}
public UserClaimRepositoryTest()
{
_context = A.Fake<EasyTeachContext>();
_userClaimRepository = new UserClaimRepository(_context);
}
