public void Upload(string initParams, T_SYS_FILEUPLOAD FileUpload) { this.State = Constants.FileStates.Uploading; _fileUploader = new WcfFileUploader(this, FileUpload); _fileUploader.Event_Upload += new EventHandler<FileUploadEventArgs>(Event_Upload); _fileUploader.UploadFinished += new EventHandler(fileUploader_UploadFinished); _fileUploader.StartUpload(initParams); }
/// <summary> /// Initializes a new instance of the <see cref="TestServerSettingsForm"/> class. /// </summary> /// <param name="server">The <see cref="IFileUploader"/> to test.</param> /// <exception cref="ArgumentNullException"><paramref name="server"/> is null.</exception> public TestServerSettingsForm(IFileUploader server) { _server = server; InitializeComponent(); Show(); }
/// <summary> /// 删除已上传的文件 /// </summary> public void Del_FileAndID() { _fileUploader = new WcfFileUploader(this); if (_fileUploader != null) { _fileUploader.UploadFinished += new EventHandler(fileUploader_DeleteFinished); _fileUploader.Del_FileAndID(); } }
public EnrollmentController(IGenericRepository repository, IMapper<CreateStudentModel, Student> enrollmentMapper, IMapper<EnterProgramStatusModel, StudentProgramStatus> programStatusMapper, IMapper<AcademicDetailModel, StudentAcademicDetail> academicDetailMapper, IFileUploader fileUploader, IMapper<AcademicDetailModel, StudentSchoolAssociation> schoolAssociationMapper, IStudentRepository studentRepository) { _fileUploader = fileUploader; _schoolAssociationMapper = schoolAssociationMapper; _studentRepository = studentRepository; _academicDetailMapper = academicDetailMapper; _repository = repository; _enrollmentMapper = enrollmentMapper; _programStatusMapper = programStatusMapper; }
public ControlPanelController(IFileUploader uploader) { _uploader = uploader; }
public ProductPictureApplication(IProductPictureRepository productPictureRepository, IFileUploader fileUploader, IProductRepository productRepository) { _productPictureRepository = productPictureRepository; _fileUploader = fileUploader; _productRepository = productRepository; }
public ArticleApplication(IArticleRepository articleRepository, IFileUploader fileUploader, IArticleCategoryRepository articleCategoryRepository) { _articleRepository = articleRepository; _fileUploader = fileUploader; _articleCategoryRepository = articleCategoryRepository; }
public UploadController(IWebHostEnvironment env, IWorkContext workContext, IFileUploader fileManager) { this._environment = env; this._workContext = workContext; _fileManager = fileManager; }
public ProductApplication(IProductRepo productRepo, IProductCategoryRepo productCategoryRepo, IFileUploader fileUploader) { _productRepo = productRepo; _productCategoryRepo = productCategoryRepo; _fileUploader = fileUploader; }
private void fileUploader_UploadFinished(object sender, EventArgs e) { _fileUploader = null; if (this.State != Enums.FileStates.Deleted && this.State != Enums.FileStates.Error) { this.State = Enums.FileStates.Finished; if (this.FileStream != null) { this.FileStream.Close(); this.FileStream.Dispose(); this.FileStream = null; } } FinishUpdates(sender, e); }
public BuildController(IFileUploader uploader) { this.uploader = uploader; }
private void fileUploader_UploadFinished(object sender, EventArgs e) { _fileUploader = null; if (State != FileStates.Deleted && State != FileStates.Error) { State = FileStates.Finished; if (FileStream != null) { FileStream.Close(); FileStream.Dispose(); FileStream = null; } FinishUpdate(sender, e); } }
private void fileUploader_UploadFinished(object sender, EventArgs e) { UIDispatcher.BeginInvoke(delegate { // close the file stream; this file will never be accessed again with this object this.FileStream.Dispose(); _fileUploader = null; this.State = Constants.FileStates.Finished; }); }
public TicketController(IMediator mediator, IFileUploader fileUploader) { _mediator = mediator; _fileUploader = fileUploader; }
public void Upload(string initParams, System.Windows.Threading.Dispatcher uiDispatcher) { State = FileStates.Uploading; _fileUploader = new HttpFileUploader(this, uiDispatcher); _fileUploader.StartUpload(initParams); _fileUploader.UploadFinished += new EventHandler(fileUploader_UploadFinished); }
public CategoriesController(IPickAndBookData data, IFileUploader fileProvider) : base(data) { this.fileUploader = fileProvider; }
/// <summary> /// 上传完成事件 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void fileUploader_UploadFinished(object sender, EventArgs e) { _fileUploader = null; this.State = Constants.FileStates.Finished; }
public AdvertsUploadController(IFileUploader fileUploader, IMapper mapper, IAdvertApiClient advertApiClient) { _fileUploader = fileUploader; _advertApiClient = advertApiClient; _mapper = mapper; }
/// <summary> /// When overridden in the derived class, handles synchronizing the given version. /// </summary> /// <param name="fu">The <see cref="IFileUploader"/> to use.</param> /// <param name="v">The version to synchronize.</param> /// <param name="reEnqueue">True if the <paramref name="v"/> should be re-enqueued so it can be re-attempted. /// If the method throws an <see cref="Exception"/>, the <paramref name="v"/> will be re-enqueued no matter what.</param> /// <returns>The error string, or null if the synchronization was successful.</returns> protected abstract string DoSync(IFileUploader fu, int v, out bool reEnqueue);
/// <summary> /// 下载 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void Download() { _fileUploader = new WcfFileUploader(this); _fileUploader.Event_Download += new EventHandler<FileDownloadEventArgs>(Event_Download); _fileUploader.Download(); }
public void CancelUpload() { if (this.FileStream != null) { this.FileStream.Close(); this.FileStream.Dispose(); this.FileStream = null; } if (_fileUploader != null && this.State == Enums.FileStates.Uploading) { _fileUploader.CancelUpload(); } _fileUploader = null; }
public FormFileImageUploader(IFileUploader fileUploader) { this.fileUploader = fileUploader; }
public ProductPictureApplication(IProductPictureRepo productPictureRepo, IProductRepo productRepo, IFileUploader fileUploader) { _productPictureRepo = productPictureRepo; _productRepo = productRepo; _fileUploader = fileUploader; }
private void fileUploader_UploadFinished(object sender, EventArgs e) { _fileUploader = null; this.State = Constants.FileStates.Finished; }
private void fileUploader_UploadErrorOccurred(object sender, UploadErrorOccurredEventArgs e) { UIDispatcher.BeginInvoke(delegate { // leave the file stream open if an upload caused an error, in case the UI allows re-sending _fileUploader = null; this.ErrorMessage = e.ErrorMessage; this.State = Constants.FileStates.Error; }); }
public UploadController(IFileUploader fileUploader) { _fileUploader = fileUploader; }
public UploadFileFromContextRequestHandler(IFileUploader fileUploader) { _fileUploader = fileUploader; }
public AdvertManagmentController(IFileUploader s3FileUploader, IAdvertApiClient advertApiCleint, IMapper mapper) { this._s3FileLoader = s3FileUploader; this._advertApiCleint = advertApiCleint; this._mapper = mapper; }
public ProductCategoryApplication(IProductCategoryRepository productCategoryRepository, IFileUploader fileUploader) { _productCategoryRepository = productCategoryRepository; _fileUploader = fileUploader; }
public ProductApplication(IProductRepository productRepository, IFileUploader fileUploader, IProductCategoryRepository productCategoryRepository) { _fileUploader = fileUploader; _productRepository = productRepository; _productCategoryRepository = productCategoryRepository; }
// GET: News public NewsController(IFileUploader fileUploader) { _fileUploader = fileUploader; }
public SignUpCase(IAppDbContext context, ILogger <SignUpCase> logger, UserManager <Entity.User> userManager, IAuthDataProvider dataProvider, IFileUploader fileUploader, Microsoft.Extensions.Configuration.IConfiguration configuration1) { _context = context; _logger = logger; _userManager = userManager; _dataProvider = dataProvider; _fileUploader = fileUploader; _configuration = configuration1; }
public EditProjectModel(IProjectData projectData, IHtmlHelper htmlHelper, IFileUploader fileUploader) { _projectData = projectData; _htmlHelper = htmlHelper; _fileUploader = fileUploader; }
public UploadManager(HttpRequestBase request, IPathResolver pathResolver, IFileUploader fileUploader) { _pathResolver = pathResolver; _fileUploader = fileUploader; _files = GetPostedFiles(request); }
public SlideApplication(ISlideRepository slideRepository, IFileUploader fileUploader) { _slideRepository = slideRepository; _fileUploader = fileUploader; }
public CategorySearch(IFileUploader fileUploader) { _fileUploader = fileUploader; }
public DeleteAccountCommandHandler(IUnitOfWork unitOfWork, IAccountRepository accountRepository, IPostRepository postRepository, IFileUploader fileUploader) { this.unitOfWork = unitOfWork; this.accountRepository = accountRepository; this.postRepository = postRepository; this.fileUploader = fileUploader; }
public ScretchesController(ApplicationDbContext context, UserManager <ApplicationUser> userManager, IFileUploader fileUploader) { _context = context; _userManager = userManager; this.fileUploader = fileUploader; }
/// <summary> /// When overridden in the derived class, handles synchronizing the given version. /// </summary> /// <param name="fu">The <see cref="IFileUploader"/> to use.</param> /// <param name="v">The version to synchronize.</param> /// <param name="reEnqueue">True if the <paramref name="v"/> should be re-enqueued so it can be re-attempted. /// If the method throws an <see cref="Exception"/>, the <paramref name="v"/> will be re-enqueued no matter what.</param> /// <returns> /// The error string, or null if the synchronization was successful. /// </returns> protected override string DoSync(IFileUploader fu, int v, out bool reEnqueue) { reEnqueue = false; // Load the VersionFileList for the version to check var vflPath = VersionHelper.GetVersionFileListPath(v); if (!File.Exists(vflPath)) { // Version doesn't exist at all return null; } var vfl = VersionFileList.CreateFromFile(vflPath); // Try to download the version's file list hash var fileListHashPath = GetVersionRemoteFilePath(v, PathHelper.RemoteFileListHashFileName); var vflHash = fu.DownloadAsString(fileListHashPath); // Check if the hash file exists on the server if (vflHash != null) { // Check if the hash matches the current version's hash var expectedVflHash = File.ReadAllText(VersionHelper.GetVersionFileListHashPath(v)); if (vflHash != expectedVflHash) { // Delete the whole version folder first fu.DeleteDirectory(GetVersionRemoteFilePath(v, null)); } else { // Hash existed and was correct - good enough for us! return null; } } else { // Hash didn't exist at all, so we will have to update. As long as SkipIfExists is set to true, files // that already exist will be skipped, so we will only end up uploading the new files. In any case, its // the same process either way. } // Check the hashes of the local files foreach (var f in vfl.Files) { // Get the local file path var localPath = VersionHelper.GetVersionFile(v, f.FilePath); // Confirm the hash of the file var fileHash = Hasher.GetFileHash(localPath); if (fileHash != f.Hash) { const string errmsg = "The cached hash ({0}) of file `{1}` does not match the real hash ({2}) for version {3}." + " Possible version corruption."; return string.Format(errmsg, f.Hash, f.FilePath, fileHash, v); } } // Hashes check out, start uploading foreach (var f in vfl.Files) { // Get the local file path var localPath = VersionHelper.GetVersionFile(v, f.FilePath); var remotePath = GetVersionRemoteFilePath(v, f.FilePath); fu.UploadAsync(localPath, remotePath); } // Wait for uploads to finish while (fu.IsBusy) { Thread.Sleep(1000); } // All uploads have finished, so upload the VersionFileList hash fu.UploadAsync(VersionHelper.GetVersionFileListHashPath(v), fileListHashPath); // All done! That was easy enough, eh? *sigh* return null; }
public EditModel(StoreDbContext dbContext, IFileUploader fileUploader) { _dbContext = dbContext; _fileUploader = fileUploader; }
/// <summary> /// Recreates the <see cref="IFileUploader"/> and starts updating again. /// </summary> void RecreateFileUploader() { // Dispose of the old uploader if (_fileUploader != null) _fileUploader.Dispose(); // Create the new uploader _fileUploader = CreateFileUploader(FileUploaderType, Host, User, Password); _lastJobsRemaining = int.MinValue; // Start the synchronization of the live and next version EnqueueSyncVersion(_settings.LiveVersion); if (_settings.DoesNextVersionExist()) EnqueueSyncVersion(_settings.LiveVersion + 1); }
/// <summary> /// When overridden in the derived class, handles synchronizing the given version. /// </summary> /// <param name="fu">The <see cref="IFileUploader"/> to use.</param> /// <param name="v">The version to synchronize.</param> /// <param name="reEnqueue">True if the <paramref name="v"/> should be re-enqueued so it can be re-attempted. /// If the method throws an <see cref="Exception"/>, the <paramref name="v"/> will be re-enqueued no matter what.</param> /// <returns>The error string, or null if the synchronization was successful.</returns> protected abstract string DoSync(IFileUploader fu, int v, out bool reEnqueue);
public void Upload(string initParams, Dispatcher uiDispatcher) { this.State = Enums.FileStates.Uploading; _fileUploader = new HttpFileUploader(this, uiDispatcher); _fileUploader.StartUpload(initParams); _fileUploader.UploadFinished += new EventHandler(fileUploader_UploadFinished); }
public CeremonyApplication(ICeremonyRepository ceremonyRepository, IFileUploader fileUploader) { _ceremonyRepository = ceremonyRepository; _fileUploader = fileUploader; }
void _server_TestConnectionMessage(IFileUploader sender, string message, object userState) { // Ensure the message is for us if (userState != this) return; // Log it Log(message); }
public AccountApplication(IAccountRepo accountRepo, IFileUploader fileUploader, IAuthHelper authHelper) { _accountRepo = accountRepo; _fileUploader = fileUploader; _authHelper = authHelper; }
/// <summary> /// Upload the file. /// </summary> /// <param name="UploadedFileProcessorType">type name for a class that will do post-processing on the uploaded files</param> /// <param name="ContextParam">Extra context parameter that is passed to the http handler</param> public void Upload(string UploadedFileProcessorType, string ContextParam) { // if we're already uploading, don't do anything if (this.State == Constants.FileStates.Uploading) return; this.State = Constants.FileStates.Uploading; if (HttpUploader) _fileUploader = new HttpFileUploader(this, UploadHandlerName, ChunkSizeMB); // for now use only the http uploader method //else // _fileUploader = new WcfFileUploader(this); _fileUploader.UploadFinished += new EventHandler(fileUploader_UploadFinished); _fileUploader.UploadCanceled += new EventHandler(fileUploader_UploadCanceled); _fileUploader.UploadDataSent += new EventHandler<UploadDataSentArgs>(fileUploader_UploadDataSent); _fileUploader.UploadErrorOccurred += new EventHandler<UploadErrorOccurredEventArgs>(fileUploader_UploadErrorOccurred); _fileUploader.UploadProcessingStarted += new EventHandler(fileUploader_UploadProcessingStarted); _fileUploader.StartUpload(UploadedFileProcessorType, ContextParam); }
public AdvertManagementController(IFileUploader fileUploader, IMapper mapper, IAdvertApiClient advertApiClient) { _mapper = mapper; _fileUploader = fileUploader; _advertApiClient = advertApiClient; }
private void fileUploader_UploadCanceled(object sender, EventArgs e) { UIDispatcher.BeginInvoke(delegate { // leave the file stream open if an upload is canceled, in case the UI allows re-sending _fileUploader = null; this.State = Constants.FileStates.Canceled; }); }
/// <summary> /// When overridden in the derived class, handles synchronizing the given version. /// </summary> /// <param name="fu">The <see cref="IFileUploader"/> to use.</param> /// <param name="v">The version to synchronize.</param> /// <param name="reEnqueue">True if the <paramref name="v"/> should be re-enqueued so it can be re-attempted. /// If the method throws an <see cref="Exception"/>, the <paramref name="v"/> will be re-enqueued no matter what.</param> /// <returns>The error string, or null if the synchronization was successful.</returns> protected override string DoSync(IFileUploader fu, int v, out bool reEnqueue) { fu.SkipIfExists = false; reEnqueue = false; var remoteFileListFilePath = PathHelper.GetVersionString(v) + ".txt"; var remoteFileListHashFilePath = PathHelper.GetVersionString(v) + ".hash"; // Ensure the live version is written. This is a very small but very important file, so just write it during // every synchronization. fu.UploadAsync(_settings.LiveVersionFilePath, MasterServerReader.CurrentVersionFilePath); // Also ensure the master server and file server lists are up-to-date. Again, we will just do this every time we // check to sync since they are relatively small lists but very important to keep up-to-date. fu.UploadAsync(_settings.FileServerListFilePath, MasterServerReader.CurrentDownloadSourcesFilePath); fu.UploadAsync(_settings.MasterServerListFilePath, MasterServerReader.CurrentMasterServersFilePath); // Load the VersionFileList for the version to check var vflPath = VersionHelper.GetVersionFileListPath(v); if (!File.Exists(vflPath)) { // Version doesn't exist at all while (fu.IsBusy) { Thread.Sleep(500); } return null; } // Test the creation of the VersionFileList to ensure its valid VersionFileList.CreateFromFile(vflPath); // Try to download the version's file list hash var vflHash = fu.DownloadAsString(remoteFileListHashFilePath); // Check if the hash file exists on the server if (vflHash != null) { // Check if the hash matches the current version's hash var expectedVflHash = File.ReadAllText(VersionHelper.GetVersionFileListHashPath(v)); if (vflHash != expectedVflHash) { // We don't need to delete anything since we make the MasterServer overwrite instead } else { // Hash existed and was correct - good enough for us! But first, wait for uploads to finish... while (fu.IsBusy) { Thread.Sleep(500); } return null; } } else { // Hash didn't exist at all, so we will have to update. As long as SkipIfExists is set to true, files // that already exist will be skipped, so we will only end up uploading the new files. In any case, its // the same process either way. } // Upload the files fu.UploadAsync(VersionHelper.GetVersionFileListPath(v), remoteFileListFilePath); fu.UploadAsync(VersionHelper.GetVersionFileListHashPath(v), remoteFileListHashFilePath); // Wait for uploads to finish while (fu.IsBusy) { Thread.Sleep(1000); } // All done! return null; }
public LoggingFileUploaderDecorator(IFileUploader uploader) { _uploader = uploader; }
public CustomerManager(IFileUploader uploader) { _uploader = uploader; }