public IrcClient(IConfiguration config, ILogger logger, IUploader uploader) { _config = config; _logger = logger; _uploader = uploader; _clients = new Dictionary <StandardIrcClient, IrcServerConfiguration>(); }
public ServiceGateway(ISerializer serializer, IDeserializer deserializer, IUploader uploader, IDeleter deleter) { _serializer = serializer; _deserializers = deserializer; _uploader = uploader; _deleter = deleter; }
public SyncService(ILoadService loadService, ILoggerFactory loggerFactory, ISecurityService security, IUploader uploader) { _loadService = loadService; _loggerFactory = loggerFactory; _security = security; _uploader = uploader; }
public UploadController(IOptions <PimsSettings> pimsSettings, IUploader uploader, ICsvParse csvParse, IHttpClient apiClient) { this.pimsSettings = pimsSettings; this.uploader = uploader; this.csvParse = csvParse; this.apiClient = apiClient; }
public UploaderViewModel(IUploader uploader, Dispatcher dispatcher) { _uploader = uploader; _dispatcher = dispatcher; _uploader.CurrentUploadChanged += (_, upload) => { _dispatcher.Invoke(() => { UpdateCurrentUpload(upload); }); }; _uploader.IsEnabledChanged += (_, __) => { OnPropertyChanged(nameof(IsEnabled)); OnPropertyChanged(nameof(IsWorking)); OnPropertyChanged(nameof(CurrentState)); startCommand?.RaiseCanExecuteChanged(); restartCommand?.RaiseCanExecuteChanged(); stopCommand?.RaiseCanExecuteChanged(); }; _uploader.IsWorkingChanged += (_, __) => { _dispatcher.Invoke(() => { OnPropertyChanged(nameof(IsWorking)); OnPropertyChanged(nameof(CurrentState)); }); }; UpdateCurrentUpload(_uploader.CurrentUpload); }
/// <summary> /// Start uploading and watching for new replays /// </summary> public async void Start(IMonitor monitor, IAnalyzer analyzer, IUploader uploader) { if (_initialized) { return; } _initialized = true; _uploader = uploader; _analyzer = analyzer; _monitor = monitor; var replays = ScanReplays(); Files.AddRange(replays); replays.Where(x => x.UploadStatus == UploadStatus.None).Reverse().Map(x => processingQueue.Add(x)); _monitor.ReplayAdded += async(_, e) => { await EnsureFileAvailable(e.Data, 3000); var replay = new ReplayFile(e.Data); Files.Insert(0, replay); processingQueue.Add(replay); }; _monitor.Start(); _analyzer.MinimumBuild = await _uploader.GetMinimumBuild(); for (int i = 0; i < MaxThreads; i++) { Task.Run(UploadLoop).Forget(); } }
public void Remove(IUploader existingUploader) { if (existingUploader == null) return; EventAggregator.GetEvent<UploaderRemoved>().Publish(existingUploader); }
public AccountController( UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, IRepositoryFactory factory, IDataManager dataManager, AppDbContext appDbContext, LePadContext lePadContext, IOptions <IdentityCookieOptions> identityCookieOptions, IEmailSender emailSender, IUploader uploader, ISmsSender smsSender, ILoggerFactory loggerFactory, IDistributedCache cache) { _userManager = userManager; _signInManager = signInManager; _repos = factory; _dataManager = dataManager; _appDbContext = appDbContext; _lepadContext = lePadContext; _externalCookieScheme = identityCookieOptions.Value.ExternalCookieAuthenticationScheme; _emailSender = emailSender; _uploader = uploader; _smsSender = smsSender; _logger = loggerFactory.CreateLogger <AccountController>(); _cache = cache; }
public UXRUploaderControlService(ISessionsControl sessions, IUploader uploader, UploadsQueue uploads, IUXRNodeContext uxrNode, UXRSessionDefinitionsSource uxrSessions) { _sessions = sessions; _uploader = uploader; _uploads = uploads; _uxrNode = uxrNode; _uxrSessions = uxrSessions; }
/// <summary> /// アップローダを追加します。<para /> /// リゾルバにも追加します。 /// </summary> /// <param name="uploader">追加するアップローダインスタンス</param> public static void RegisterUploader(IUploader uploader) { if (!uploaders.Contains(uploader)) { uploaders.Add(uploader); } RegisterResolver(uploader); }
public CloudProxyApplication(IAppConfiguration appConfiguration, IUploader uploader, IServiceQueueClient queueClient) { _appConfiguration = appConfiguration ?? throw new ArgumentNullException(nameof(appConfiguration)); _uploader = uploader ?? throw new ArgumentNullException(nameof(uploader)); _queueClient = queueClient ?? throw new ArgumentNullException(nameof(uploader)); _processingCancellationTokenSource = new CancellationTokenSource(_processingTimeoutDuration); }
public DiscordClient() { Settings = new DiscordSettings(); Client = new DiscordSocketClient(); Uploader = new DiscordUploader(); LocalUploader = new LocalUploader(); SetupBot(); }
public CommonController(ISystemService systemService , IWebContext webContext , IUploader uploader ) { _systemService = systemService; _webContext = webContext; _uploader = uploader; }
/// <summary> /// Create email confirmation token /// </summary> /// <param name="uploader">user</param> /// <returns>confirmation token</returns> public virtual async Task <string> CreateConfirmationTokenAsync(IUploader uploader) { if (uploader == null) { throw new ArgumentNullException(nameof(uploader)); } return(await userManager.GenerateEmailConfirmationTokenAsync(uploader as GalleryUser)); }
/// <summary> /// Create password recovery token /// </summary> /// <param name="uploader"></param> /// <returns></returns> public virtual Task <string> CreatePasswordRecoveryTokenAsync(IUploader uploader) { if (uploader == null) { throw new ArgumentNullException(nameof(uploader)); } return(Task.FromResult(manager.CreatePasswordRecoveryToken(uploader as AppUser))); }
/// <summary> /// Constructor /// </summary> public JobProcessorTwitter(IDownloader downloader, IUploader uploader, TwitterSchemaToItemMapper twitterItemMapper) { url = SettingsTwitter.TwitterEndPoint + "/1.1/statuses/user_timeline.json"; AppID = SettingsTwitter.TwitterApiKey; AppSecret = SettingsTwitter.TwitterApiSecretKey; this.twitterItemMapper = twitterItemMapper; this.downloader = downloader; this.uploader = uploader; }
/// <summary> /// Create password recovery token /// </summary> /// <param name="uploader">user</param> /// <returns>password recovery token</returns> public virtual async Task <string> CreatePasswordRecoveryTokenAsync(IUploader uploader) { if (uploader == null) { throw new ArgumentNullException(nameof(uploader)); } return(await userManager.GeneratePasswordResetTokenAsync(uploader as GalleryUser)); }
/// <summary> /// Start uploading and watching for new replays /// </summary> public async void Start(IMonitor monitor, PreMatchIMonitor prematch_monitor, IAnalyzer analyzer, IUploader uploader) { if (_initialized) { return; } _initialized = true; _uploader = uploader; _analyzer = analyzer; _monitor = monitor; _prematch_monitor = prematch_monitor; var replays = ScanReplays(); Files.AddRange(replays); replays.Where(x => x.UploadStatus == UploadStatus.None).Reverse().Map(x => processingQueue.Add(x)); _monitor.ReplayAdded += async(_, e) => { await EnsureFileAvailable(e.Data, 3000); var replay = new ReplayFile(e.Data); Files.Insert(0, replay); processingQueue.Add(replay); if (PreMatchPage) { _prematch_monitor.Start(); } }; _monitor.Start(); /* * _prematch_monitor.TempBattleLobbyCreated += async (_, e) => { * if (PreMatchPage) { * prematch_id = 0; * _prematch_monitor.Stop(); * Thread.Sleep(1000); * var tmpPath = Path.GetTempFileName(); * await SafeCopy(e.Data, tmpPath, true); * byte[] bytes = System.IO.File.ReadAllBytes(tmpPath); * Replay replay = MpqBattlelobby.Parse(bytes); * await runPreMatch(replay); * } * }; * _prematch_monitor.Start(); */ _analyzer.MinimumBuild = await _uploader.GetMinimumBuild(); for (int i = 0; i < MaxThreads; i++) { Task.Run(UploadLoop).Forget(); } }
public UploadViewModel() { object val = localSettings.Values[DeveloperSettingKey]; if (val != null && val is string) { DeveloperName = (string)val; } uploader = new AzureStorageUploader(); }
public void Demonstrate() { NetworkManager nm = new NetworkManager(); IDownloader id = nm; id.Start(); IUploader ip = nm; ip.Start(); }
/// <summary> /// Initializes a new instance of the <see cref="UploadDataSourceFileCommandHandler"/> class. /// </summary> /// <param name="queryHandler">Injected query handler</param> /// <param name="uploader">Injected uploader</param> public UploadDataSourceFileCommandHandler( IQueryHandler <CreateStreamFromPathQuery, CreateStreamFromPathQueryResult> queryHandler, IUploader <DataSourceFileUploadCommand> uploader) { Argument.NotNull(queryHandler, nameof(queryHandler)); Argument.NotNull(uploader, nameof(uploader)); _queryHandler = queryHandler; _uploader = uploader; }
/// <summary> /// Initializes a new instance of the <see cref="LogUploaderDecorator{TCommand}"/> class /// </summary> /// <param name="uploader">Injected uploader</param> /// <param name="logger">Injected application logger</param> public DebugUploaderDecorator( IUploader <TCommand> uploader, IApplicationLogger logger) : base(uploader) { Argument.NotNull(uploader, nameof(uploader)); Argument.NotNull(logger, nameof(logger)); _uploader = uploader; _logger = logger; }
private static void Upload(IUploader uploader, string filePath) { for (int iteration = 0; iteration < 100; iteration++) { Console.WriteLine(iteration); using (var stream = File.OpenRead(filePath)) { uploader.Upload(stream, iteration); } } }
/// <summary> /// Initializes a new instance of the <see cref="CheckUploadNeededUploaderDecorator{TCommand}"/> class /// </summary> /// <param name="uploader">Injected file uploader</param> /// <param name="queryHandler">Injected query handler</param> public CheckUploadNeededUploaderDecorator( IUploader <TCommand> uploader, IQueryHandler <FileNeedsUploadQuery, FileNeedsUploadQueryResult> queryHandler) : base(uploader) { Argument.NotNull(uploader, nameof(uploader)); Argument.NotNull(queryHandler, nameof(queryHandler)); _uploader = uploader; _queryHandler = queryHandler; }
public ContentsController(IRepositoryFactory factory, UserManager <AppUser> userManager, INotificationManager notificationManager, IUploader uploader, IMapper mapper) { _repos = factory; _userManager = userManager; _notify = notificationManager; _uploader = uploader; _mapper = mapper; }
public ProgressForm(UploadFile[] files, string url, string user, string password) { InitializeComponent(); this.files = files; this.url = url; this.user = user; this.password = password; total = 0; currentBytes = 0; ques = new Queue<UploadFile>(files); uploader = UploaderFactory.CreateInstance(); currentPercent = 0; }
public ProgressForm(UploadFile[] files, string url, string user, string password) { InitializeComponent(); this.files = files; this.url = url; this.user = user; this.password = password; total = 0; currentBytes = 0; ques = new Queue <UploadFile>(files); uploader = UploaderFactory.CreateInstance(); currentPercent = 0; }
public ContentsController(INotificationManager notificationManager, IRepositoryFactory factory, IProgressTracker progressTracker, UserManager <AppUser> userManager, IUploader uploader, IMapper mapper) { _notify = notificationManager; _repos = factory; _progressTracker = progressTracker; _userManager = userManager; _uploader = uploader; _mapper = mapper; }
public ProgressableStreamContent(IUploader Uploader, Stream content, int bufferSize = defaultBufferSize) { this.Uploader = Uploader ?? throw new ArgumentNullException("Uploader"); this.content = content ?? throw new ArgumentNullException("content"); if (bufferSize < minBuffersSize) // Less than 1kb for uplaoding is crazy! { throw new ArgumentOutOfRangeException("bufferSize", $"Minimum Buffer Size is {minBuffersSize}"); } else { this.bufferSize = bufferSize; } }
protected AstmIOController( IAstmChannel stream, AstmLowLevelSettings lowLevelSettings, IUploader uploader, IDownloader downloader, ITimersManager timersManager, ILogger <AstmIOController> log) { _stream = stream; _uploader = uploader; _downloader = downloader; _lowLevelSettings = lowLevelSettings; _timersManager = timersManager; _log = log; _timersManager.CreateTimer(DISABLE_UPLOAD_TIMER_NAME); }
/// <summary> /// External login using SignInManager /// </summary> /// <returns></returns> public virtual async Task <bool> ExecuteExternalLogin() { var result = await signInManager.GetExternalLoginInfoAsync(); if (result == null) // error in authentication { return(false); } ExternalAuthFactory authFactory = ExternalAuthFactory.GetInstance(result.LoginProvider); if (authFactory != null && !authFactory.CanAuthenticate(result.Principal.Claims)) { return(false); } IUploader uploader = await GetUserByIdAsync(authFactory.Identifier); if (uploader != null) //User already registered so sign him in { await signInManager.SignInAsync(uploader as GalleryUser, false); // login user return(true); } string password = Guid.NewGuid().ToString().Substring(0, 8); // password can be random because user will never type in this password var galleryUser = new GalleryUser { Id = authFactory.Identifier, Email = authFactory.Email, UserName = authFactory.UserName, IsExternal = true }; var resultOfRegistration = await RegistrationProcess(galleryUser, password); if (!resultOfRegistration.Success) // registration unsuccessful { return(false); } await signInManager.SignInAsync(resultOfRegistration.Result as GalleryUser, false); // login user return(true); }
private TelemetryClient( IApplicationConfiguration applicationConfiguration, IPlatformProxy platformProxy, IErrorStore errorStore, IUploader uploader, IActionStore actionStore, IScenarioStore scenarioStore, ContextStore contextStore, bool isScenarioUploadDisabled) { TelemetryManager = new TelemetryManager(applicationConfiguration, platformProxy, ProcessTelemetryCallback); _errorStore = errorStore; _uploader = uploader; _actionStore = actionStore; _scenarioStore = scenarioStore; _contextStore = contextStore; _isScenarioUploadDisabled = isScenarioUploadDisabled; }
/// <summary> /// アップローダを追加します。<para /> /// リゾルバにも追加します。 /// </summary> /// <param name="uploader">追加するアップローダインスタンス</param> public static void RegisterUploader(IUploader uploader) { if (!uploaders.Contains(uploader)) uploaders.Add(uploader); RegisterResolver(uploader); }