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){
}
