public SiccarStatusCache( ISiccarTransactionRequestor transactionRequestor, IProgressReportRequestor progressReportRequestor, IUserCache userCache, ISiccarTransactionCache siccarTransactionCache, IProgressReportCache progressReportCache, IProcessSchemaCache processSchemaCache, IUserJustCompletedStepCache userJustCompletedStepCache, ISiccarStatusCacheResponseManager siccarStatusCacheResponseManager, IProgressReportModelManager progressReportModelManager, ISiccarTransactionManager siccarTransactionManager ) { _transactionRequestor = transactionRequestor; _progressReportRequestor = progressReportRequestor; _userCache = userCache; _siccarTransactionCache = siccarTransactionCache; _progressReportModelManager = progressReportModelManager; _progressReportCache = progressReportCache; _processSchemaCache = processSchemaCache; _siccarStatusCacheResponseManager = siccarStatusCacheResponseManager; _siccarTransactionManager = siccarTransactionManager; _userJustCompletedStepCache = userJustCompletedStepCache; }
public ConnectionsController( IUserCache userCache, IUserRepository userRepository) { UserCache = userCache; UserRepository = userRepository; }
static CacheFactory() { accountCache = Activator.CreateInstance(Type.GetType("LOLServer.cache.impl.AccountCache")) as IAccountCache; userCache = Activator.CreateInstance(Type.GetType("LOLServer.cache.impl.UserCache")) as IUserCache; //accountCache =new AccountCache(); //userCache = new UserCache(); }
public UpdateServiceAsync(IBotService botService, IServiceProxy serviceProxy, IUserCache userCache) { _botService = botService.ThrowIfNull(nameof(botService)); _serviceProxy = serviceProxy.ThrowIfNull(nameof(serviceProxy)); _userCache = userCache.ThrowIfNull(nameof(userCache)); }
public SiccarStatusCacheResponseManager(IUserCache userCache, ISiccarTransactionCache siccarTransactionCache, IProgressReportCache progressReportCache, IProcessSchemaCache processSchemaCache, IUserJustCompletedStepCache userJustCompletedStepCache) { _userCache = userCache; _siccarTransactionCache = siccarTransactionCache; _progressReportCache = progressReportCache; _processSchemaCache = processSchemaCache; _userJustCompletedStepCache = userJustCompletedStepCache; }
public AvatarRemovedHandler(IHandler handler, IUserRepository userRepository, IUserCache cache) { _handler = handler; _userRepository = userRepository; _cache = cache; }
public PermissionProvider( IServerConfiguration serverConfiguration , IUserCache userCache) { _ServerConfiguration = serverConfiguration; _UserCache = userCache; _AdministratorPermission = _ServerConfiguration.AdministratorPermissionName; }
public RoomModuleViewModel(IRoom room, IMessageBus bus, IUserCache userCache, IChatDocument chatDocument, IClipboardService clipboardService, IGlobalCommands commands) { _room = room; _bus = bus; _userCache = userCache; _chatDocument = chatDocument; Topic = _room.Topic; Users = new ReactiveCollection <UserViewModel>(); UserMessage = String.Empty; PostMessageCommand = new ReactiveCommand(this.ObservableForProperty(vm => vm.UserEditedMessage) .Select(c => c.Value).StartWith(false)); Subscribe(() => PostMessageCommand.Subscribe(HandlePostMessage)); _messages = new List <RoomMessage>(); Subscribe(() => _bus.RegisterMessageSource( _bus.Listen <ConnectionState>() .Where(msg => msg.RoomId == room.Id) .Do(cs => IsConnected = cs.Connected) .Where(cs => cs.Connected) .Delay(TimeSpan.FromSeconds(10), RxApp.TaskpoolScheduler) .Where(_ => _streamingStarted && IsConnected) .Select(_ => new RequestRecentMessagesMessage(_room.Id)))); ; Subscribe( () => _bus.Listen <MessagesReceivedMessage>().Where(msg => msg.RoomId == room.Id).SubscribeUI(HandleMessagesReceived)); Subscribe( () => _bus.Listen <RoomInfoReceivedMessage>().Where(msg => msg.Room.Id == _room.Id).SubscribeUI(HandleRoomInfoReceived)); Subscribe(() => _bus.Listen <UsersUpdatedMessage>().SubscribeUI(HandleUsersUpdated)); _bus.SendMessage(new RequestRecentMessagesMessage(room.Id)); _bus.SendMessage(new RequestRoomInfoMessage(_room.Id)); Subscribe(() => _bus.RegisterMessageSource(Observable.Interval(TimeSpan.FromMinutes(5)).Select( _ => new RequestKeepAliveMessage(_room.Id)))); PasteCommand = new ReactiveCommand(); Subscribe(() => PasteCommand.Select(pc => clipboardService.GetClipboardItem()) .Where(ci => ci != null) .Subscribe(ci => _chatDocument.AddPasteFile(_room, ci))); var leaveRoomCommand = commands.LeaveRoomCommand.OfType <int>().Where(id => id == _room.Id); Subscribe(_bus.RegisterMessageSource(leaveRoomCommand.Select(_ => new RequestStopStreamingMessage(_room.Id)))); Subscribe(_bus.RegisterMessageSource(leaveRoomCommand.Select(_ => new RequestLeaveRoomMessage(_room.Id)))); Subscribe( _bus.RegisterMessageSource( leaveRoomCommand.Select(_ => new ActivateModuleByIdMessage(ModuleNames.MainCampfireView, ModuleIds.Lobby)))); }
/// <summary> /// Creates a new object. /// </summary> public BasicAuthenticationHelper() { _UserManager = Factory.ResolveSingleton <IUserManager>(); _UserCache = Factory.Resolve <IUserCache>(); _UserCache.LoadAllUsers = false; _UserCache.TagAction = (cachedUser) => cachedUser.Tag = new CachedUserTag(); _UserCache.Refresh(); }
public RemarkDeletedHandler(IHandler handler, IRemarkRepository repository, IRemarkCache remarkCache, IUserCache userCache) { _handler = handler; _repository = repository; _remarkCache = remarkCache; _userCache = userCache; }
static cacheFactory() { CreatePath(); AccaountCache = new AccountCache(NameAndPath["AccountFile"]); UserCache = new UserCache(); PosCache = new PosCache(); SkillCache = new SkillCache(); InventoryCache = new InventoryCache(); }
public AccountUnlockedHandler(IHandler handler, IUserRepository userRepository, IAccountStateService stateService, IUserCache cache) { _handler = handler; _userRepository = userRepository; _stateService = stateService; _cache = cache; }
public UsernameChangedHandler(IHandler handler, IUserRepository userRepository, IRemarkRepository remarkRepository, IUserCache cache) { _handler = handler; _userRepository = userRepository; _remarkRepository = remarkRepository; _cache = cache; }
public AccountActivatedHandler(IHandler handler, IUserRepository repository, IAccountStateService stateService, IUserCache cache) { _handler = handler; _repository = repository; _stateService = stateService; _cache = cache; }
/// <summary> /// Creates a new object. /// </summary> public BasicAuthenticationFilter() { _SharedConfiguration = Factory.Singleton.ResolveSingleton <ISharedConfiguration>(); _AuthenticationConfiguration = Factory.Singleton.ResolveSingleton <IAuthenticationConfiguration>(); _UserManager = Factory.Singleton.ResolveSingleton <IUserManager>(); _UserCache = Factory.Singleton.Resolve <IUserCache>(); _UserCache.LoadAllUsers = false; _UserCache.TagAction = (cachedUser) => cachedUser.Tag = new CachedUserTag(); _UserCache.Refresh(); }
private static IUserCache GetUserCache(IConfig settings) { IUserCache cache = null; if (settings.ContainsAttribute(CacheTypeElement, QualifiedNameAttribute)) { var typeName = settings.GetAttribute(CacheTypeElement, QualifiedNameAttribute); cache = (IUserCache)CreateInstance(typeName, settings); } return(cache ?? new GenericUserCache(settings)); }
public ProfilesController( IUserApiClient userApiClient, ILogger <ProfilesController> logger, IUserCache userCache, IMapperFactory mapperFactory) { _userApiClient = userApiClient; _logger = logger; _userCache = userCache; _mapperFactory = mapperFactory; }
public MemberAddedToOrganizationHandler(IHandler handler, IOrganizationRepository organizationRepository, IUserRepository userRepository, IOrganizationCache organizationCache, IUserCache userCache) { _handler = handler; _organizationRepository = organizationRepository; _userRepository = userRepository; _organizationCache = organizationCache; _userCache = userCache; }
public FavoriteRemarkAddedHandler(IHandler handler, IUserRepository userRepository, IRemarkRepository remarkRepository, IRemarkCache remarkCache, IUserCache userCache) { _handler = handler; _userRepository = userRepository; _remarkRepository = remarkRepository; _remarkCache = remarkCache; _userCache = userCache; }
protected UserRepositoryBase(string name, IConfig config, IPredefinedNames predefinedNames, IUserCache cache) { if(name == null) { throw new ArgumentNullException("name"); } if(config == null) { throw new ArgumentNullException("config"); } this.name = name; this.config = config; this.predefinedNames = predefinedNames; this.cache = cache; }
public SignedInHandler(IHandler handler, IUserRepository repository, IUserServiceClient userServiceClient, IAccountStateService accountStateService, IUserCache cache) { _handler = handler; _repository = repository; _userServiceClient = userServiceClient; _accountStateService = accountStateService; _cache = cache; }
public RemarkCreatedHandler(IHandler handler, IRemarkRepository remarkRepository, IRemarkServiceClient remarkServiceClient, IRemarkCache remarkCache, IUserCache userCache) { _handler = handler; _remarkRepository = remarkRepository; _remarkServiceClient = remarkServiceClient; _remarkCache = remarkCache; _userCache = userCache; }
public MemberAddedToGroupHandler(IHandler handler, IGroupRepository groupRepository, IUserRepository userRepository, IGroupCache groupCache, IUserCache userCache) { _handler = handler; _groupRepository = groupRepository; _userRepository = userRepository; _groupCache = groupCache; _userCache = userCache; }
public LoginManager(IUserCache loggedInPool) { _userCache = loggedInPool ?? throw new ArgumentNullException(nameof(loggedInPool)); _listeners = new Dictionary <string, HashSet <UserLoggedOutHandle> >(); _loggedOutUsers = new BlockingCollection <string>(); new Thread(LogOutHandler) { IsBackground = true }.Start(); _userCache.UsersTimedOutEvent += OnUsersTimedOutHandler; }
public OrganizationCreatedHandler(IHandler handler, IOrganizationRepository organizationRepository, IUserRepository userRepository, IGroupServiceClient groupServiceClient, IOrganizationCache organizationCache, IUserCache userCache) { _handler = handler; _organizationRepository = organizationRepository; _userRepository = userRepository; _groupServiceClient = groupServiceClient; _organizationCache = organizationCache; _userCache = userCache; }
public CachedUserDAO(IUserDAO userDao, IUserCache cache) { if (userDao == null) { throw new ArgumentNullException("userDao"); } if (cache == null) { throw new ArgumentNullException("cache"); } _userDao = userDao; _cache = cache; }
public MilestoneController(IMilestoneRepository milestoneRepo, IAuthtenticationCurrentContext currentAuthContext, ICacheProvider cacheP, IMapper automapper, IUserRepository userrepo, ILikeRepository likeRepo, IUserCache usrCache, IAmazonS3ImageProvider amazons3imageprovider ) { milestoneRepository = milestoneRepo; currentAuthenticationContext = currentAuthContext; cacheProvider = cacheP; mapper = automapper; userRepository = userrepo; likeRepository = likeRepo; userCache = usrCache; amazonS3ImageProvider = amazons3imageprovider; }
protected UserRepositoryBase(string name, IConfig config, IPredefinedNames predefinedNames, IUserCache cache) { if (name == null) { throw new ArgumentNullException("name"); } if (config == null) { throw new ArgumentNullException("config"); } this.name = name; this.config = config; this.predefinedNames = predefinedNames; this.cache = cache; }
public WebAuthenticator(IJumbleblocksSecurityService securityService, IFormsAuthentication formsAuthentication, IUserCache userCache) { if (securityService == null) throw new ArgumentNullException("securityService"); if (userCache == null) throw new ArgumentNullException("userCache"); if (formsAuthentication == null) throw new ArgumentNullException("formsAuthentication"); SecurityService = securityService; FormsAuthentication = formsAuthentication; UserCache = userCache; }
private bool Authorize(Role role, string login, string token) { IUserCache userCache = NinjectHttpContainer.Resolve <IUserCache>(); var auth = userCache.GetAuthByLogin(login); //var cachedToken = userCache.GetTokenByLogin(login); //var user = userCache.GetUserByToken(token); if (auth == null || auth.GetUser() == null || auth.GetToken() == null || auth.GetToken() != token || auth.GetLogin() != login) { return(false); } var ret = auth.GetRole() >= role; if (ret) { AuthenticationUtils.CurrentAuthentication = auth; } return(ret); }
public User_listService( IUser_listVistor user_listVistor, IHttpContextAccessor contextAccessor, IUserStore userStore, IPub_DictVistor pub_DictVistor, IPub_DicExtendItemVistor pub_DicExtendItemVistor, IOrg_ListVistor org_ListVistor, IOrgStore orgStore, IUserCache userCache, IPinYinLibraryHelper pinYinLibraryHelper) { _user_listVistor = user_listVistor; _contextAccessor = contextAccessor; _userStore = userStore; _pub_DictVistor = pub_DictVistor; _pub_DicExtendItemVistor = pub_DicExtendItemVistor; _org_ListVistor = org_ListVistor; _orgStore = orgStore; _userCache = userCache; _pinYinLibraryHelper = pinYinLibraryHelper; //初始化用户缓存数据 UserCacheList(false); }
public static ILoginManager GetInstance(IUserCache pool = null) { return(_instance ?? (_instance = new LoginManager(pool ?? new UserCache(new CountDownTimer())))); }
public SettingsStorage(ILocalCache localCache, ISecureCache roamingSecureCache, IUserCache roamingCache) { _localCache = localCache; _roamingSecureCache = roamingSecureCache; _roamingCache = roamingCache; _settings = new Lazy<Settings>(() => Task.Run(() => LoadSettings()).Result); }
public UserSettingsCacheManager(IUserCache cache) { Contract.Requires<ArgumentNullException>(cache != null); _cache = cache; }
static CacheFactory() { accountCache = new AccountCache(); userCache = new UserCache(); }
public NotificationTransformer(IMessageBus bus, IUserCache userCache) { _bus = bus; _userCache = userCache; }
public UserRepositoryAdapter(string name, IConfig config, IPredefinedNames predefinedNames, IUserCache cache) : base(name, config, predefinedNames, cache){ }