Example #1
0
 public IrcClient(IConfiguration config, ILogger logger, IUploader uploader)
 {
     _config   = config;
     _logger   = logger;
     _uploader = uploader;
     _clients  = new Dictionary <StandardIrcClient, IrcServerConfiguration>();
 }
Example #2
0
 public ServiceGateway(ISerializer serializer, IDeserializer deserializer, IUploader uploader, IDeleter deleter)
 {
     _serializer    = serializer;
     _deserializers = deserializer;
     _uploader      = uploader;
     _deleter       = deleter;
 }
Example #3
0
 public SyncService(ILoadService loadService, ILoggerFactory loggerFactory, ISecurityService security, IUploader uploader)
 {
     _loadService   = loadService;
     _loggerFactory = loggerFactory;
     _security      = security;
     _uploader      = uploader;
 }
Example #4
0
 public UploadController(IOptions <PimsSettings> pimsSettings, IUploader uploader, ICsvParse csvParse, IHttpClient apiClient)
 {
     this.pimsSettings = pimsSettings;
     this.uploader     = uploader;
     this.csvParse     = csvParse;
     this.apiClient    = apiClient;
 }
Example #5
0
        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);
        }
Example #6
0
        /// <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);
        }
Example #8
0
 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;
 }
Example #9
0
 public UXRUploaderControlService(ISessionsControl sessions, IUploader uploader, UploadsQueue uploads, IUXRNodeContext uxrNode, UXRSessionDefinitionsSource uxrSessions)
 {
     _sessions    = sessions;
     _uploader    = uploader;
     _uploads     = uploads;
     _uxrNode     = uxrNode;
     _uxrSessions = uxrSessions;
 }
Example #10
0
 /// <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);
        }
Example #12
0
 public DiscordClient()
 {
     Settings      = new DiscordSettings();
     Client        = new DiscordSocketClient();
     Uploader      = new DiscordUploader();
     LocalUploader = new LocalUploader();
     SetupBot();
 }
Example #13
0
 public CommonController(ISystemService systemService
                         , IWebContext webContext
                         , IUploader uploader
                         )
 {
     _systemService = systemService;
     _webContext    = webContext;
     _uploader      = uploader;
 }
Example #14
0
        /// <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));
        }
Example #15
0
        /// <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;
 }
Example #17
0
        /// <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));
        }
Example #18
0
        /// <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();
            }
        }
Example #19
0
        public UploadViewModel()
        {
            object val = localSettings.Values[DeveloperSettingKey];

            if (val != null && val is string)
            {
                DeveloperName = (string)val;
            }
            uploader = new AzureStorageUploader();
        }
Example #20
0
        public void Demonstrate()
        {
            NetworkManager nm = new NetworkManager();
            IDownloader    id = nm;

            id.Start();
            IUploader ip = nm;

            ip.Start();
        }
Example #21
0
        /// <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;
        }
Example #22
0
        /// <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;
        }
Example #23
0
 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);
         }
     }
 }
Example #24
0
        /// <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;
 }
Example #27
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;
 }
Example #29
0
        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;
            }
        }
Example #30
0
 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);
 }
Example #31
0
        /// <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;
        }
Example #33
0
 /// <summary>
 /// アップローダを追加します。<para />
 /// リゾルバにも追加します。
 /// </summary>
 /// <param name="uploader">追加するアップローダインスタンス</param>
 public static void RegisterUploader(IUploader uploader)
 {
     if (!uploaders.Contains(uploader))
         uploaders.Add(uploader);
     RegisterResolver(uploader);
 }