public PostService(IMapper mapper, IPostRepository repository, IEmployeeRepository userRepository, ICacheHandler cacheHandler)
{
_mapper = mapper;
_repository = repository;
_userRepository = userRepository;
_cacheHandler = cacheHandler;
}
public DefaultAccountPermissionResolver(ICacheHandler cache, IServiceScopeFactory scopeFactory)
{
_cache = cache;
_scopeFactory = scopeFactory;
Scoped();
}
public DiscordEventHandler(IDiscordClient client, ICacheHandler cacheHandler)
{
this.client = client;
this.cacheHandler = cacheHandler;
channelCreate = new Subject <IDiscordChannel>();
channelDelete = new Subject <IDiscordChannel>();
channelUpdate = new Subject <IDiscordChannel>();
guildAvailable = new Subject <IDiscordGuild>();
guildCreate = new Subject <IDiscordGuild>();
guildDelete = new Subject <IDiscordGuild>();
guildJoin = new Subject <IDiscordGuild>();
guildLeave = new Subject <IDiscordGuild>();
guildUpdate = new Subject <IDiscordGuild>();
guildUnavailable = new Subject <IDiscordGuild>();
guildEmojiUpdate = new Subject <DiscordEmoji>();
guildMemberCreate = new Subject <IDiscordGuildUser>();
guildMemberDelete = new Subject <IDiscordGuildUser>();
guildMemberUpdate = new Subject <IDiscordGuildUser>();
guildRoleCreate = new Subject <IDiscordRole>();
guildRoleDelete = new Subject <IDiscordRole>();
guildRoleUpdate = new Subject <IDiscordRole>();
messageCreate = new Subject <IDiscordMessage>();
messageDelete = new Subject <IDiscordMessage>();
messageUpdate = new Subject <IDiscordMessage>();
messageReactionCreate = new Subject <IDiscordReaction>();
messageReactionDelete = new Subject <IDiscordReaction>();
presenceUpdate = new Subject <IDiscordPresence>();
typingStart = new Subject <TypingStartEventArgs>();
userUpdate = new Subject <IDiscordUser>();
}
public ConfigContainer(ICacheHandler cacheHandler, IConfigStorage storage, IModuleCollection moduleCollection, ILogger <ConfigContainer> logger)
{
_cacheHandler = cacheHandler;
_storage = storage;
_moduleCollection = moduleCollection;
_logger = logger;
}
public PermissionService(IPermissionRepository permissionRepository, IModuleRepository moduleRepository, ICacheHandler cacheHandler, IConfigProvider configProvider)
{
_repository = permissionRepository;
_moduleRepository = moduleRepository;
_cacheHandler = cacheHandler;
_configProvider = configProvider;
}
public VideoThumnailUtility(ICacheHandler cacheHandler)
{
this.cacheHandler = cacheHandler;
this.thumbConfigs = new Queue <ThumbConfig>();
this.niconicoIDsAndActions = new Dictionary <string, Action>();
this.lockObj = new object();
}
public DictItemService(IDictItemRepository repository, IMapper mapper, IOptionsMonitor <CommonOptions> optionsMonitor, ICacheHandler cacheHandler)
{
_repository = repository;
_mapper = mapper;
_options = optionsMonitor.CurrentValue;
_cacheHandler = cacheHandler;
}
public MenuItemService(IRepository<AuthorityMenuItemInfo, Guid> menuItemRepository, IMenuAppService menuAppService, ICacheHandler cache)
{
_menuItemRepository = menuItemRepository;
_menuAppService =menuAppService;
cacheHandler = cache;
}
public AreaService(IMapper mapper, IAreaRepository repository, IUnitOfWork <CommonDbContext> uow, ICacheHandler cache)
{
_mapper = mapper;
_repository = repository;
_uow = uow;
_cache = cache;
}
//public void Scoped()
//{
// //using (var scope = _scopeFactory.CreateScope())
// //{
// var scope = _scopeFactory.CreateScope();
// //}
// // Other code
//}
public PermissionValidateHandler(ICacheHandler cache, ILoginInfo logininfo, IAccountPermissionResolver permissionResolver)
{
_loginInfo = logininfo;
_permissionResolver = permissionResolver;
//_scopeFactory = scopeFactory;
//Scoped();
}
public AuthService(
IMapper mapper
, ICacheHandler cacheHandler
, ILoginInfo loginInfo
, IUserRepository userRepository
, IRoleUserRepository roleUserRepository
, IUserAuthRepository userAuthRepository
, IMenuRepository menuRepository
, IPermissionRepository permissionRepository
, ISkinRepository skinRepository
, IUserService userService
, IPasswordHandler passwordHandler
)
{
_mapper = mapper;
_cacheHandler = cacheHandler;
_loginInfo = loginInfo;
_userRepository = userRepository;
_roleUserRepository = roleUserRepository;
_userAuthRepository = userAuthRepository;
_menuRepository = menuRepository;
_permissionRepository = permissionRepository;
_skinRepository = skinRepository;
_userService = userService;
_passwordHandler = passwordHandler;
}
public AreaService(IMapper mapper, IAreaRepository repository, ICacheHandler cache, CommonDbContext dbContext)
{
_mapper = mapper;
_repository = repository;
_cache = cache;
_dbContext = dbContext;
}
public MemberService(IMapper mapper, IMemberRepository repository,
ICacheHandler cacheHandler)
{
_mapper = mapper;
_repository = repository;
_cacheHandler = cacheHandler;
}
public ExampleServiceHelper(IWebServiceHelper serviceHelper, ICacheHandler cacheHandler, ILogHelper logHelper, ISettingsHelper settingsHelper)
{
this.ServiceHelper = serviceHelper;
this.CacheHandler = cacheHandler;
this.LogHelper = logHelper;
this.SettingsHelper = settingsHelper;
}
public OrganizeService(IMapper mapper, ILoginInfo loginInfo, IOrganizeRepository organizeRepository, IUserRepository userRepository, ICacheHandler cacheHandler)
{
_mapper = mapper;
_loginInfo = loginInfo;
_organizeRepository = organizeRepository;
_userRepository = userRepository;
_cacheHandler = cacheHandler;
}
public RoutesManager(IRoutesRepository routesRepository, ICacheHandler cacheHandler, IStatisticsService statisticsService, IElasticService elasticService) : base(routesRepository)
{
_routesRepository = routesRepository;
_cragsCache = cacheHandler.CragsCache;
_cragsCacheLock = cacheHandler.CragsCacheLock;
_statisticsService = statisticsService;
_elasticService = elasticService;
}
public PermissionService(IPermissionRepository permissionRepository, AdminDbContext dbContext, IModuleInfoRepository moduleInfoRepository, SystemConfigModel systemConfig, ICacheHandler cacheHandler)
{
_repository = permissionRepository;
_dbContext = dbContext;
_moduleInfoRepository = moduleInfoRepository;
_systemConfig = systemConfig;
_cacheHandler = cacheHandler;
}
public CragsManager(ICragsRepository cragsRepository, ICacheHandler cacheHandler, IStatisticsService statisticsService, IElasticService elasticService) : base(cragsRepository)
{
_cragsRepository = cragsRepository;
_cragsCache = cacheHandler.CragsCache;
_cragsCacheLock = cacheHandler.CragsCacheLock;
_statisticsService = statisticsService;
_elasticService = elasticService;
}
public AreasManager(IAreasRepository areasRepository, ICacheHandler cacheHandler, IStatisticsService statisticsService, IElasticService elasticService) : base(areasRepository)
{
_areasRepository = areasRepository;
_cragsCache = cacheHandler.CragsCache;
_cragsCacheLock = cacheHandler.CragsCacheLock;
_statisticsService = statisticsService;
_elasticService = elasticService;
}
public DefaultAccountPermissionResolver(ICacheHandler cache, IRolePermissionRepository rolePermissionRepository, IRoleButtonRepository roleButtonRepository, IRolePageRepository rolePageRepository, IMenuRepository menuRepository)
{
_cache = cache;
_rolePermissionRepository = rolePermissionRepository;
_roleButtonRepository = roleButtonRepository;
_rolePageRepository = rolePageRepository;
_menuRepository = menuRepository;
}
public DictService(IMapper mapper, IDictRepository repository, ICacheHandler cacheHandler, IDictItemRepository itemRepository, IConfigProvider configProvider)
{
_mapper = mapper;
_repository = repository;
_cacheHandler = cacheHandler;
_itemRepository = itemRepository;
_configProvider = configProvider;
}
public RoleService(IRepository<AuthorityRoleInfo, Guid> roleRepository, IRepository<AuthorityMenuAppInfo, Guid> menuAppRepository, ICacheHandler cache,IRepository<AuthorityFunctionPermissionInfo, Guid> rolePermissionRepository,IRepository<AuthorityUserRoleInfo, Guid> userRoleRepository)
{
_roleRepository = roleRepository;
_menuAppRepository = menuAppRepository;
_rolePermissionRepository = rolePermissionRepository;
_userRoleRepository = userRoleRepository;
cacheHandler = cache;
}
public DictItemService(IDictItemRepository repository, IMapper mapper, ICacheHandler cacheHandler, IDictItemNoticeProvider noticeProvider, IConfigProvider configProvider, IDictSyncProvider dictNameSyncProvider)
{
_repository = repository;
_mapper = mapper;
_cacheHandler = cacheHandler;
_noticeProvider = noticeProvider;
_configProvider = configProvider;
_dictNameSyncProvider = dictNameSyncProvider;
}
public AuthService(IMemberRepository repository, IPasswordHandler passwordHandler,
ICacheHandler cacheHandler,
ForumDbContext dbContext)
{
_repository = repository;
_passwordHandler = passwordHandler;
_dbContext = dbContext;
_cacheHandler = cacheHandler;
}
public UserNameOrEmailLoginHandler(IVerifyCodeProvider verifyCodeProvider, IConfigProvider configProvider,
IAccountAuthInfoRepository authInfoRepository, IAccountRepository repository,
IPasswordHandler passwordHandler, ICacheHandler cacheHandler, ILoginLogHandler logHandler,
ILogger <UserNameLoginHandler> logger) : base(verifyCodeProvider, configProvider, authInfoRepository,
cacheHandler, logHandler, logger)
{
_repository = repository;
_passwordHandler = passwordHandler;
}
protected LoginHandlerAbstract(IVerifyCodeProvider verifyCodeProvider, IConfigProvider configProvider, IAccountAuthInfoRepository authInfoRepository, ICacheHandler cacheHandler, ILoginLogHandler logHandler, ILogger logger)
{
_verifyCodeProvider = verifyCodeProvider;
_configProvider = configProvider;
_authInfoRepository = authInfoRepository;
_cacheHandler = cacheHandler;
_logHandler = logHandler;
_logger = logger;
}
public CacheHandlerRegister WithHandler(ICacheHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (_cacheHandlers.Contains(handler))
{
throw new InvalidOperationException(SR.HanderAlreadyExistsError);
}
_cacheHandlers.Add(handler);
WithAsyncHitHandler <object>(handler.GetPriority(CacheHandlerType.Hit), async ctx =>
{
if (handler.Enabled)
{
await handler.OnHit(ctx);
}
});
WithAsyncMissHandler <object>(handler.GetPriority(CacheHandlerType.Miss), async ctx =>
{
if (handler.Enabled)
{
await handler.OnMiss(ctx);
}
});
WithAsyncStoreHandler <object>(handler.GetPriority(CacheHandlerType.Store), async ctx =>
{
if (handler.Enabled)
{
await handler.OnStore(ctx);
}
});
WithAsyncExpiringHandler(handler.GetPriority(CacheHandlerType.Expiring), async ctx =>
{
if (handler.Enabled)
{
await handler.OnExpiring(ctx);
}
});
WithAsyncExpiredHandler(handler.GetPriority(CacheHandlerType.Expired), async ctx =>
{
if (handler.Enabled)
{
await handler.OnExpired(ctx);
}
});
return(this);
}
public SystemService(IUnitOfWork <AdminDbContext> uow, IConfigRepository configRepository, IModuleInfoService moduleInfoService, ICacheHandler cache, IAccountRepository accountRepository, IAccountRoleRepository accountRoleRepository)
{
_uow = uow;
_configRepository = configRepository;
_moduleInfoService = moduleInfoService;
//_roleRepository = roleRepository;
_cache = cache;
_accountRepository = accountRepository;
_accountRoleRepository = accountRoleRepository;
}
public CategoryService(IMapper mapper,
ICategoryRepository repository,
ForumDbContext dbContext,
ICacheHandler cacheHandler)
{
_mapper = mapper;
_cacheHandler = cacheHandler;
_repository = repository;
_dbContext = dbContext;
}
public ModuleService(IModuleRepository repository, IModuleCollection moduleCollection, AdminDbContext dbContext, ILogger <ModuleService> logger, IAuditInfoRepository auditInfoRepository, ICacheHandler cacheHandler, IPermissionRepository permissionRepository)
{
_repository = repository;
_moduleCollection = moduleCollection;
_dbContext = dbContext;
_logger = logger;
_auditInfoRepository = auditInfoRepository;
_cacheHandler = cacheHandler;
_permissionRepository = permissionRepository;
}
public PermissionService(IPermissionRepository permissionRepository, AdminDbContext dbContext, IModuleRepository moduleRepository, SystemConfigModel systemConfig, ICacheHandler cacheHandler, ILogger <PermissionService> logger, AdminOptions options)
{
_repository = permissionRepository;
_dbContext = dbContext;
_moduleRepository = moduleRepository;
_systemConfig = systemConfig;
_cacheHandler = cacheHandler;
_logger = logger;
_options = options;
}
public SystemService(IConfigRepository configRepository, IModuleInfoService moduleInfoService, IPermissionService permissionService, IRoleRepository roleRepository, ICacheHandler cache, IAccountRepository accountRepository, IAccountRoleRepository accountRoleRepository)
{
_configRepository = configRepository;
_moduleInfoService = moduleInfoService;
_permissionService = permissionService;
_roleRepository = roleRepository;
_cache = cache;
_accountRepository = accountRepository;
_accountRoleRepository = accountRoleRepository;
}
public LabourTeamService(IRepository<BaseLabourTeamInfo, Guid> labourTeamRepository, ICacheHandler cache)
{
_labourTeamRepository = labourTeamRepository;
cacheHandler = cache;
}
public ProjectSupplierService(IRepository<BaseProjectSupplierInfo, Guid> projectSupplierRepository, ICacheHandler cache)
{
_projectSupplierRepository = projectSupplierRepository;
cacheHandler = cache;
}
public UserService(IRepository<AuthorityUserInfo, Guid> userRepository, ICacheHandler cache)
{
_userRepository = userRepository;
_cache = cache;
}
public BootstrapIconService(ICacheHandler cache)
{
cacheHandler = cache;
}
public StorePostionService(IRepository<BaseStorePostionInfo, Guid> storePostionRepository, ICacheHandler cache)
{
_storePostionRepository = storePostionRepository;
cacheHandler = cache;
}
public SupplierService(IRepository<BaseSupplierInfo, Guid> supplierRepository, ICacheHandler cache)
{
_supplierRepository = supplierRepository;
cacheHandler = cache;
}
public MizoreCacheException(ICacheHandler cache, Exception innerException)
: this(cache, innerException.Message, innerException)
{
}
public ConversionRateService(IRepository<BaseConversionRateInfo, Guid> conversionRateRepository,ICacheHandler cache)
{
_conversionRateRepository = conversionRateRepository;
cacheHandler = cache;
}
public MizoreCacheException(ICacheHandler cache, string message, Exception innerException)
: base(message, innerException)
{
CacheHandler = cache;
}
public DataDictionaryDetailService(IRepository<BaseDataDictionaryDetailInfo, Guid> dataDictionaryDetailRepository, ICacheHandler cache)
{
_dataDictionaryDetailRepository = dataDictionaryDetailRepository;
cacheHandler = cache;
}
public ProjectCodeService(IRepository<BaseProjectCodeInfo, Guid> projectCodeRepository, ICacheHandler cache)
{
_projectCodeRepository = projectCodeRepository;
cacheHandler = cache;
}
public MenuPermissionService(IRepository<AuthorityMenuPermissionInfo, Guid> menuPermissionRepository, ICacheHandler cache)
{
_menuPermissionRepository = menuPermissionRepository;
cacheHandler = cache;
}
public ProvinceCityService(IRepository<BaseProvinceCityInfo, Guid> provinceCityRepository, ICacheHandler cache)
{
_provinceCityRepository = provinceCityRepository;
cacheHandler = cache;
}
public AnimeHandler(ICacheHandler cacheHandler, IMappingToJson jsonMapper)
{
_cacheHandler = cacheHandler;
_jsonMapper = jsonMapper;
}
public OrganizeService(IRepository<AuthorityOrganizeInfo, Guid> organizeRepository, ICacheHandler cache)
{
_organizeRepository = organizeRepository;
cacheHandler = cache;
}
public MenuItemService(IRepository<AuthorityMenuItemInfo, Guid> menuItemRepository, ICacheHandler cache)
{
_menuItemRepository = menuItemRepository;
_cache = cache;
}
public UserService(IRepository<AuthorityUserInfo, Guid> userRepository, ICacheHandler cache, IPermissionManager permissionManager)
{
_userRepository = userRepository;
cacheHandler = cache;
_permissionManager = permissionManager;
}
public ProjectMaterialInfoService(IRepository<BaseProjectMaterialInfo, Guid> projectMaterialInfoRepository, ICacheHandler cache)
{
_projectMaterialInfoRepository = projectMaterialInfoRepository;
cacheHandler = cache;
}
public MenuAppService(IRepository<AuthorityMenuAppInfo, Guid> menuAppRepository, ICacheHandler cache)
{
_menuAppRepository = menuAppRepository;
cacheHandler = cache;
}
public FunctionService(IRepository<AuthorityFunctionInfo, Guid> functionRepository, ICacheHandler cache, ITypeFinder typeFinder)
{
_functionRepository = functionRepository;
cacheHandler = cache;
_typeFinder = typeFinder;
}
public MaterialClassService(IRepository<BaseMaterialClassInfo, Guid> materialClassRepository, IRepository<BaseMaterialInfo, Guid> materialInfoRepository, ICacheHandler cache)
{
_materialClassRepository = materialClassRepository;
_materialInfoRepository = materialInfoRepository;
cacheHandler = cache;
}
public CodeRuleService(IRepository<BaseCodeRuleInfo, Guid> codeRuleRepository, ICacheHandler cache)
{
_codeRuleRepository = codeRuleRepository;
cacheHandler = cache;
}
public RoleService(IRepository<AuthorityRoleInfo, Guid> roleRepository, IMenuAppService menuAppService, ICacheHandler cache)
{
_roleRepository = roleRepository;
_menuAppService = menuAppService;
cacheHandler = cache;
}
public EmployeeService(IRepository<BaseEmployeeInfo, Guid> employeeRepository, ICacheHandler cache)
{
_employeeRepository = employeeRepository;
cacheHandler = cache;
}
