2013-11-03 23:53:49 +13:00
|
|
|
|
#region License Information (GPL v3)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
ShareX - A program that allows you to take screenshots and share any file type
|
2018-01-02 03:59:14 +13:00
|
|
|
|
Copyright (c) 2007-2018 ShareX Team
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
|
|
|
|
|
|
Optionally you can also view the license at <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#endregion License Information (GPL v3)
|
|
|
|
|
|
2014-12-11 09:25:20 +13:00
|
|
|
|
using ShareX.HelpersLib;
|
2014-10-17 22:58:15 +13:00
|
|
|
|
using ShareX.Properties;
|
2014-12-11 09:25:20 +13:00
|
|
|
|
using ShareX.UploadersLib;
|
2016-02-15 19:53:30 +13:00
|
|
|
|
using System;
|
2016-09-17 19:07:02 +12:00
|
|
|
|
using System.Collections.Generic;
|
2016-05-31 00:00:12 +12:00
|
|
|
|
using System.Diagnostics;
|
2016-02-15 19:53:30 +13:00
|
|
|
|
using System.Drawing;
|
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Net;
|
|
|
|
|
using System.Text;
|
2018-04-25 11:29:44 +12:00
|
|
|
|
using System.Text.RegularExpressions;
|
2016-02-15 19:53:30 +13:00
|
|
|
|
using System.Threading;
|
|
|
|
|
using System.Windows.Forms;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
|
|
|
|
namespace ShareX
|
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public class WorkerTask : IDisposable
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public delegate void TaskEventHandler(WorkerTask task);
|
2016-04-30 10:26:49 +12:00
|
|
|
|
public delegate void UploaderServiceEventHandler(IUploaderService uploaderService);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-12-13 01:19:02 +13:00
|
|
|
|
public event TaskEventHandler StatusChanged, UploadStarted, UploadProgressChanged, UploadCompleted, TaskCompleted;
|
2016-04-30 10:26:49 +12:00
|
|
|
|
public event UploaderServiceEventHandler UploadersConfigWindowRequested;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
|
|
|
|
public TaskInfo Info { get; private set; }
|
|
|
|
|
public TaskStatus Status { get; private set; }
|
2016-12-13 01:19:02 +13:00
|
|
|
|
public bool IsBusy => Status == TaskStatus.InQueue || IsWorking;
|
|
|
|
|
public bool IsWorking => Status == TaskStatus.Preparing || Status == TaskStatus.Working || Status == TaskStatus.Stopping;
|
2014-06-09 04:36:47 +12:00
|
|
|
|
public bool StopRequested { get; private set; }
|
2013-11-03 23:53:49 +13:00
|
|
|
|
public bool RequestSettingUpdate { get; private set; }
|
2015-08-17 12:01:10 +12:00
|
|
|
|
public Stream Data { get; private set; }
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
|
|
|
|
private Image tempImage;
|
|
|
|
|
private string tempText;
|
|
|
|
|
private ThreadWorker threadWorker;
|
2016-04-15 12:25:08 +12:00
|
|
|
|
private GenericUploader uploader;
|
2016-03-23 12:56:39 +13:00
|
|
|
|
private TaskReferenceHelper taskReferenceHelper;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2014-04-23 09:55:49 +12:00
|
|
|
|
private static string lastSaveAsFolder;
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
#region Constructors
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
private WorkerTask(TaskSettings taskSettings)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
Status = TaskStatus.InQueue;
|
|
|
|
|
Info = new TaskInfo(taskSettings);
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-23 07:28:02 +13:00
|
|
|
|
public static WorkerTask CreateHistoryTask(RecentTask recentTask)
|
|
|
|
|
{
|
|
|
|
|
WorkerTask task = new WorkerTask(null);
|
|
|
|
|
task.Status = TaskStatus.History;
|
|
|
|
|
task.Info.FilePath = recentTask.FilePath;
|
|
|
|
|
task.Info.FileName = recentTask.FileName;
|
|
|
|
|
task.Info.Result.URL = recentTask.URL;
|
2016-02-24 06:13:05 +13:00
|
|
|
|
task.Info.Result.ThumbnailURL = recentTask.ThumbnailURL;
|
|
|
|
|
task.Info.Result.DeletionURL = recentTask.DeletionURL;
|
|
|
|
|
task.Info.Result.ShortenedURL = recentTask.ShortenedURL;
|
2017-06-12 08:01:11 +12:00
|
|
|
|
task.Info.TaskEndTime = recentTask.Time;
|
2016-02-24 06:13:05 +13:00
|
|
|
|
|
2016-02-23 07:28:02 +13:00
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public static WorkerTask CreateDataUploaderTask(EDataType dataType, Stream stream, string fileName, TaskSettings taskSettings)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.Job = TaskJob.DataUpload;
|
|
|
|
|
task.Info.DataType = dataType;
|
|
|
|
|
task.Info.FileName = fileName;
|
|
|
|
|
task.Data = stream;
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public static WorkerTask CreateFileUploaderTask(string filePath, TaskSettings taskSettings)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.FilePath = filePath;
|
2015-08-17 12:01:10 +12:00
|
|
|
|
task.Info.DataType = TaskHelpers.FindDataType(task.Info.FilePath, taskSettings);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
string ext = Path.GetExtension(task.Info.FilePath);
|
|
|
|
|
task.Info.FileName = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-17 12:01:10 +12:00
|
|
|
|
if (task.Info.TaskSettings.AdvancedSettings.ProcessImagesDuringFileUpload && task.Info.DataType == EDataType.Image)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-06-05 03:20:13 +12:00
|
|
|
|
task.Info.Job = TaskJob.Job;
|
2015-08-17 12:01:10 +12:00
|
|
|
|
task.tempImage = ImageHelpers.LoadImage(task.Info.FilePath);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
task.Info.Job = TaskJob.FileUpload;
|
2014-12-06 05:44:19 +13:00
|
|
|
|
|
2015-08-17 12:01:10 +12:00
|
|
|
|
if (!task.LoadFileStream())
|
2014-12-06 05:44:19 +13:00
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-27 11:48:18 +13:00
|
|
|
|
public static WorkerTask CreateImageUploaderTask(ImageInfo imageInfo, TaskSettings taskSettings, string customFileName = null)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2014-06-05 03:20:13 +12:00
|
|
|
|
task.Info.Job = TaskJob.Job;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.DataType = EDataType.Image;
|
2015-10-23 11:43:04 +13:00
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(customFileName))
|
|
|
|
|
{
|
|
|
|
|
task.Info.FileName = Helpers.AppendExtension(customFileName, "bmp");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2017-02-27 11:48:18 +13:00
|
|
|
|
task.Info.FileName = TaskHelpers.GetFilename(taskSettings, "bmp", imageInfo);
|
2015-10-23 11:43:04 +13:00
|
|
|
|
}
|
|
|
|
|
|
2017-02-27 11:48:18 +13:00
|
|
|
|
task.tempImage = imageInfo.Image;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public static WorkerTask CreateTextUploaderTask(string text, TaskSettings taskSettings)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.Job = TaskJob.TextUpload;
|
|
|
|
|
task.Info.DataType = EDataType.Text;
|
2014-05-11 23:47:37 +12:00
|
|
|
|
task.Info.FileName = TaskHelpers.GetFilename(taskSettings, taskSettings.AdvancedSettings.TextFileExtension);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.tempText = text;
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public static WorkerTask CreateURLShortenerTask(string url, TaskSettings taskSettings)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.Job = TaskJob.ShortenURL;
|
|
|
|
|
task.Info.DataType = EDataType.URL;
|
2014-10-25 13:04:41 +13:00
|
|
|
|
task.Info.FileName = string.Format(Resources.UploadTask_CreateURLShortenerTask_Shorten_URL___0__, taskSettings.URLShortenerDestination.GetLocalizedDescription());
|
2013-11-03 23:53:49 +13:00
|
|
|
|
task.Info.Result.URL = url;
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:03:03 +12:00
|
|
|
|
public static WorkerTask CreateShareURLTask(string url, TaskSettings taskSettings)
|
2014-07-08 04:02:32 +12:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2014-07-08 04:02:32 +12:00
|
|
|
|
task.Info.Job = TaskJob.ShareURL;
|
|
|
|
|
task.Info.DataType = EDataType.URL;
|
2014-10-25 13:04:41 +13:00
|
|
|
|
task.Info.FileName = string.Format(Resources.UploadTask_CreateShareURLTask_Share_URL___0__, taskSettings.URLSharingServiceDestination.GetLocalizedDescription());
|
2014-07-08 04:02:32 +12:00
|
|
|
|
task.Info.Result.URL = url;
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-23 11:43:04 +13:00
|
|
|
|
public static WorkerTask CreateFileJobTask(string filePath, TaskSettings taskSettings, string customFileName = null)
|
2014-06-05 03:20:13 +12:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2014-06-05 03:20:13 +12:00
|
|
|
|
task.Info.FilePath = filePath;
|
2015-08-17 12:01:10 +12:00
|
|
|
|
task.Info.DataType = TaskHelpers.FindDataType(task.Info.FilePath, taskSettings);
|
2014-06-05 03:20:13 +12:00
|
|
|
|
|
2015-10-23 11:43:04 +13:00
|
|
|
|
if (!string.IsNullOrEmpty(customFileName))
|
|
|
|
|
{
|
|
|
|
|
string ext = Path.GetExtension(task.Info.FilePath);
|
|
|
|
|
task.Info.FileName = Helpers.AppendExtension(customFileName, ext);
|
|
|
|
|
}
|
|
|
|
|
else if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
|
2014-06-05 03:20:13 +12:00
|
|
|
|
{
|
|
|
|
|
string ext = Path.GetExtension(task.Info.FilePath);
|
|
|
|
|
task.Info.FileName = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
task.Info.Job = TaskJob.Job;
|
|
|
|
|
|
2015-08-17 12:01:10 +12:00
|
|
|
|
if (task.Info.IsUploadJob && !task.LoadFileStream())
|
2014-06-05 03:20:13 +12:00
|
|
|
|
{
|
2015-08-17 12:01:10 +12:00
|
|
|
|
return null;
|
2014-06-05 03:20:13 +12:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-20 12:54:17 +12:00
|
|
|
|
public static WorkerTask CreateDownloadTask(string url, bool upload, TaskSettings taskSettings)
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
2015-08-31 18:03:03 +12:00
|
|
|
|
WorkerTask task = new WorkerTask(taskSettings);
|
2016-07-20 12:54:17 +12:00
|
|
|
|
task.Info.Job = upload ? TaskJob.DownloadUpload : TaskJob.Download;
|
2015-08-29 18:11:37 +12:00
|
|
|
|
|
2015-08-31 18:20:20 +12:00
|
|
|
|
string filename = URLHelpers.URLDecode(url, 10);
|
|
|
|
|
filename = URLHelpers.GetFileName(filename);
|
|
|
|
|
filename = Helpers.GetValidFileName(filename);
|
|
|
|
|
|
2016-03-16 23:06:56 +13:00
|
|
|
|
if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
|
|
|
|
|
{
|
|
|
|
|
string ext = Path.GetExtension(filename);
|
|
|
|
|
filename = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:20:20 +12:00
|
|
|
|
if (string.IsNullOrEmpty(filename))
|
2015-08-29 18:11:37 +12:00
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 18:20:20 +12:00
|
|
|
|
task.Info.FileName = filename;
|
2017-10-10 11:06:05 +13:00
|
|
|
|
task.Info.DataType = TaskHelpers.FindDataType(task.Info.FileName, taskSettings);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
task.Info.Result.URL = url;
|
|
|
|
|
return task;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
#endregion Constructors
|
|
|
|
|
|
|
|
|
|
public void Start()
|
|
|
|
|
{
|
2014-06-09 04:36:47 +12:00
|
|
|
|
if (Status == TaskStatus.InQueue && !StopRequested)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2017-06-12 08:01:11 +12:00
|
|
|
|
Info.TaskStartTime = DateTime.Now;
|
2016-05-31 00:00:12 +12:00
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
threadWorker = new ThreadWorker();
|
2016-04-30 10:26:49 +12:00
|
|
|
|
Prepare();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
threadWorker.DoWork += ThreadDoWork;
|
|
|
|
|
threadWorker.Completed += ThreadCompleted;
|
|
|
|
|
threadWorker.Start(ApartmentState.STA);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Prepare()
|
|
|
|
|
{
|
|
|
|
|
Status = TaskStatus.Preparing;
|
|
|
|
|
|
|
|
|
|
switch (Info.Job)
|
|
|
|
|
{
|
2014-06-05 03:20:13 +12:00
|
|
|
|
case TaskJob.Job:
|
2013-11-03 23:53:49 +13:00
|
|
|
|
case TaskJob.TextUpload:
|
2014-10-17 22:58:15 +13:00
|
|
|
|
Info.Status = Resources.UploadTask_Prepare_Preparing;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
break;
|
|
|
|
|
default:
|
2014-10-17 22:58:15 +13:00
|
|
|
|
Info.Status = Resources.UploadTask_Prepare_Starting;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OnStatusChanged();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void Stop()
|
|
|
|
|
{
|
2014-06-09 04:36:47 +12:00
|
|
|
|
StopRequested = true;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2014-06-09 04:36:47 +12:00
|
|
|
|
switch (Status)
|
|
|
|
|
{
|
|
|
|
|
case TaskStatus.InQueue:
|
2016-05-18 01:43:04 +12:00
|
|
|
|
OnTaskCompleted();
|
2014-06-09 04:36:47 +12:00
|
|
|
|
break;
|
|
|
|
|
case TaskStatus.Preparing:
|
|
|
|
|
case TaskStatus.Working:
|
|
|
|
|
if (uploader != null) uploader.StopUpload();
|
|
|
|
|
Status = TaskStatus.Stopping;
|
2014-10-17 22:58:15 +13:00
|
|
|
|
Info.Status = Resources.UploadTask_Stop_Stopping;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
OnStatusChanged();
|
2014-06-09 04:36:47 +12:00
|
|
|
|
break;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void ThreadDoWork()
|
|
|
|
|
{
|
2016-03-23 12:56:39 +13:00
|
|
|
|
CreateTaskReferenceHelper();
|
|
|
|
|
|
2014-07-19 07:13:32 +12:00
|
|
|
|
try
|
|
|
|
|
{
|
2014-07-30 22:36:35 +12:00
|
|
|
|
StopRequested = !DoThreadJob();
|
|
|
|
|
|
|
|
|
|
if (!StopRequested)
|
|
|
|
|
{
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (Info.IsUploadJob && !Program.Settings.DisableUpload)
|
|
|
|
|
{
|
|
|
|
|
DoUploadJob();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Info.Result.IsURLExpected = false;
|
|
|
|
|
}
|
2014-07-30 22:36:35 +12:00
|
|
|
|
}
|
2014-07-19 07:13:32 +12:00
|
|
|
|
}
|
|
|
|
|
finally
|
|
|
|
|
{
|
|
|
|
|
Dispose();
|
|
|
|
|
|
|
|
|
|
if (Info.Job == TaskJob.Job && Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.DeleteFile) && !string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
|
|
|
|
|
{
|
|
|
|
|
File.Delete(Info.FilePath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!StopRequested && Info.Result != null && Info.Result.IsURLExpected && !Info.Result.IsError)
|
|
|
|
|
{
|
|
|
|
|
if (string.IsNullOrEmpty(Info.Result.URL))
|
|
|
|
|
{
|
2016-04-04 21:12:21 +12:00
|
|
|
|
AddErrorMessage(Resources.UploadTask_ThreadDoWork_URL_is_empty_);
|
2014-07-19 07:13:32 +12:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
DoAfterUploadJobs();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-03-23 12:56:39 +13:00
|
|
|
|
private void CreateTaskReferenceHelper()
|
|
|
|
|
{
|
|
|
|
|
taskReferenceHelper = new TaskReferenceHelper()
|
|
|
|
|
{
|
|
|
|
|
DataType = Info.DataType,
|
|
|
|
|
OverrideFTP = Info.TaskSettings.OverrideFTP,
|
|
|
|
|
FTPIndex = Info.TaskSettings.FTPIndex,
|
|
|
|
|
OverrideCustomUploader = Info.TaskSettings.OverrideCustomUploader,
|
|
|
|
|
CustomUploaderIndex = Info.TaskSettings.CustomUploaderIndex,
|
|
|
|
|
TextFormat = Info.TaskSettings.AdvancedSettings.TextFormat
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-19 07:13:32 +12:00
|
|
|
|
private void DoUploadJob()
|
|
|
|
|
{
|
2018-05-19 05:39:01 +12:00
|
|
|
|
if (Program.Settings.ShowUploadWarning && MessageBox.Show(Resources.UploadTask_DoUploadJob_First_time_upload_warning_text,
|
2016-04-20 04:23:44 +12:00
|
|
|
|
"ShareX - " + Resources.UploadTask_DoUploadJob_First_time_upload_warning,
|
|
|
|
|
MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-04-20 04:23:44 +12:00
|
|
|
|
Program.Settings.ShowUploadWarning = false;
|
|
|
|
|
Program.DefaultTaskSettings.AfterCaptureJob = Program.DefaultTaskSettings.AfterCaptureJob.Remove(AfterCaptureTasks.UploadImageToHost);
|
|
|
|
|
RequestSettingUpdate = true;
|
|
|
|
|
Stop();
|
|
|
|
|
}
|
2015-08-15 10:44:10 +12:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (Program.Settings.LargeFileSizeWarning > 0)
|
|
|
|
|
{
|
|
|
|
|
long dataSize = Program.Settings.BinaryUnits ? Program.Settings.LargeFileSizeWarning * 1024 * 1024 : Program.Settings.LargeFileSizeWarning * 1000 * 1000;
|
|
|
|
|
if (Data != null && Data.Length > dataSize)
|
2015-08-15 10:44:10 +12:00
|
|
|
|
{
|
2016-04-20 04:23:44 +12:00
|
|
|
|
using (MyMessageBox msgbox = new MyMessageBox(Resources.UploadTask_DoUploadJob_You_are_attempting_to_upload_a_large_file, "ShareX",
|
|
|
|
|
MessageBoxButtons.YesNo, Resources.UploadManager_IsUploadConfirmed_Don_t_show_this_message_again_))
|
2015-08-15 10:44:10 +12:00
|
|
|
|
{
|
2016-04-20 04:23:44 +12:00
|
|
|
|
msgbox.ShowDialog();
|
|
|
|
|
if (msgbox.IsChecked) Program.Settings.LargeFileSizeWarning = 0;
|
|
|
|
|
if (msgbox.DialogResult == DialogResult.No) Stop();
|
2015-08-15 10:44:10 +12:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-04-20 04:23:44 +12:00
|
|
|
|
}
|
2015-08-15 10:44:10 +12:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (!StopRequested)
|
|
|
|
|
{
|
|
|
|
|
Program.Settings.ShowUploadWarning = false;
|
|
|
|
|
|
2017-03-27 04:19:52 +13:00
|
|
|
|
SettingManager.WaitUploadersConfig();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
Status = TaskStatus.Working;
|
|
|
|
|
Info.Status = Resources.UploadTask_DoUploadJob_Uploading;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
TaskbarManager.SetProgressState(Program.MainForm, TaskbarProgressBarStatus.Normal);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
bool cancelUpload = false;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.ShowBeforeUploadWindow))
|
|
|
|
|
{
|
2017-08-06 08:04:21 +12:00
|
|
|
|
using (BeforeUploadForm form = new BeforeUploadForm(Info))
|
|
|
|
|
{
|
|
|
|
|
cancelUpload = form.ShowDialog() != DialogResult.OK;
|
|
|
|
|
}
|
2016-04-20 04:23:44 +12:00
|
|
|
|
}
|
2014-05-13 04:51:09 +12:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (!cancelUpload)
|
|
|
|
|
{
|
2016-04-30 10:26:49 +12:00
|
|
|
|
OnUploadStarted();
|
2014-04-13 18:59:18 +12:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
bool isError = DoUpload();
|
2014-05-13 04:51:09 +12:00
|
|
|
|
|
2016-04-20 04:23:44 +12:00
|
|
|
|
if (isError && Program.Settings.MaxUploadFailRetry > 0)
|
|
|
|
|
{
|
2018-06-11 05:39:48 +12:00
|
|
|
|
for (int retry = 1; !StopRequested && isError && retry <= Program.Settings.MaxUploadFailRetry; retry++)
|
2016-04-20 04:23:44 +12:00
|
|
|
|
{
|
2018-06-11 05:39:48 +12:00
|
|
|
|
DebugHelper.WriteLine("Upload failed. Retrying upload.");
|
2016-04-20 04:23:44 +12:00
|
|
|
|
isError = DoUpload(retry);
|
2014-04-13 17:22:31 +12:00
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2016-05-31 00:00:12 +12:00
|
|
|
|
|
|
|
|
|
if (!isError)
|
|
|
|
|
{
|
|
|
|
|
OnUploadCompleted();
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2016-04-20 04:23:44 +12:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Info.Result.IsURLExpected = false;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-13 17:22:31 +12:00
|
|
|
|
private bool DoUpload(int retry = 0)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
bool isError = false;
|
|
|
|
|
|
2014-04-13 18:59:18 +12:00
|
|
|
|
if (retry > 0)
|
2014-04-13 17:22:31 +12:00
|
|
|
|
{
|
2014-04-13 18:59:18 +12:00
|
|
|
|
if (Program.Settings.UseSecondaryUploaders)
|
|
|
|
|
{
|
2014-05-11 23:47:37 +12:00
|
|
|
|
Info.TaskSettings.ImageDestination = Program.Settings.SecondaryImageUploaders[retry - 1];
|
|
|
|
|
Info.TaskSettings.ImageFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
|
|
|
|
|
Info.TaskSettings.TextDestination = Program.Settings.SecondaryTextUploaders[retry - 1];
|
|
|
|
|
Info.TaskSettings.TextFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
|
|
|
|
|
Info.TaskSettings.FileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
|
2014-04-13 18:59:18 +12:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Thread.Sleep(1000);
|
|
|
|
|
}
|
2014-04-13 17:22:31 +12:00
|
|
|
|
}
|
|
|
|
|
|
2016-03-14 14:10:19 +13:00
|
|
|
|
SSLBypassHelper sslBypassHelper = null;
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
try
|
|
|
|
|
{
|
2016-03-14 14:10:19 +13:00
|
|
|
|
if (HelpersOptions.AcceptInvalidSSLCertificates)
|
|
|
|
|
{
|
|
|
|
|
sslBypassHelper = new SSLBypassHelper();
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-28 23:05:56 +13:00
|
|
|
|
if (!CheckUploadFilters(Data, Info.FileName))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-10-28 23:05:56 +13:00
|
|
|
|
switch (Info.UploadDestination)
|
|
|
|
|
{
|
|
|
|
|
case EDataType.Image:
|
|
|
|
|
Info.Result = UploadImage(Data, Info.FileName);
|
|
|
|
|
break;
|
|
|
|
|
case EDataType.Text:
|
|
|
|
|
Info.Result = UploadText(Data, Info.FileName);
|
|
|
|
|
break;
|
|
|
|
|
case EDataType.File:
|
|
|
|
|
Info.Result = UploadFile(Data, Info.FileName);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2016-03-23 11:36:41 +13:00
|
|
|
|
|
2016-03-23 12:56:39 +13:00
|
|
|
|
StopRequested |= taskReferenceHelper.StopRequested;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
catch (Exception e)
|
|
|
|
|
{
|
2014-06-09 04:36:47 +12:00
|
|
|
|
if (!StopRequested)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
DebugHelper.WriteException(e);
|
|
|
|
|
isError = true;
|
2016-04-04 21:12:21 +12:00
|
|
|
|
AddErrorMessage(e.ToString());
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
finally
|
|
|
|
|
{
|
2016-03-14 14:10:19 +13:00
|
|
|
|
if (sslBypassHelper != null)
|
|
|
|
|
{
|
|
|
|
|
sslBypassHelper.Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:12:21 +12:00
|
|
|
|
if (Info.Result == null)
|
|
|
|
|
{
|
|
|
|
|
Info.Result = new UploadResult();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (uploader != null)
|
|
|
|
|
{
|
|
|
|
|
AddErrorMessage(uploader.Errors.ToArray());
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
isError |= Info.Result.IsError;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return isError;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:12:21 +12:00
|
|
|
|
private void AddErrorMessage(params string[] errorMessages)
|
|
|
|
|
{
|
|
|
|
|
if (Info.Result == null)
|
|
|
|
|
{
|
|
|
|
|
Info.Result = new UploadResult();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Info.Result.Errors.AddRange(errorMessages);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-30 22:36:35 +12:00
|
|
|
|
private bool DoThreadJob()
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-07-23 08:32:28 +12:00
|
|
|
|
if (Info.IsUploadJob && Info.TaskSettings.AdvancedSettings.AutoClearClipboard)
|
|
|
|
|
{
|
|
|
|
|
ClipboardHelpers.Clear();
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-20 12:54:17 +12:00
|
|
|
|
if (Info.Job == TaskJob.Download || Info.Job == TaskJob.DownloadUpload)
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
2016-07-20 22:35:45 +12:00
|
|
|
|
bool downloadResult = DownloadFromURL(Info.Job == TaskJob.DownloadUpload);
|
2016-07-20 12:54:17 +12:00
|
|
|
|
|
|
|
|
|
if (!downloadResult)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
else if (Info.Job == TaskJob.Download)
|
|
|
|
|
{
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2015-08-17 12:01:10 +12:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-05 03:20:13 +12:00
|
|
|
|
if (Info.Job == TaskJob.Job)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-17 09:51:18 +12:00
|
|
|
|
if (!DoAfterCaptureJobs())
|
2014-06-05 03:20:13 +12:00
|
|
|
|
{
|
2014-07-30 22:36:35 +12:00
|
|
|
|
return false;
|
2014-06-05 03:20:13 +12:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DoFileJobs();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
else if (Info.Job == TaskJob.TextUpload && !string.IsNullOrEmpty(tempText))
|
|
|
|
|
{
|
2015-07-27 03:42:14 +12:00
|
|
|
|
DoTextJobs();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2015-08-17 12:01:10 +12:00
|
|
|
|
else if (Info.Job == TaskJob.FileUpload && Info.TaskSettings.AdvancedSettings.UseAfterCaptureTasksDuringFileUpload)
|
2015-08-17 09:51:18 +12:00
|
|
|
|
{
|
|
|
|
|
DoFileJobs();
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-05-13 11:43:33 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.DoOCR))
|
|
|
|
|
{
|
|
|
|
|
DoOCR();
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
if (Info.IsUploadJob && Data != null && Data.CanSeek)
|
|
|
|
|
{
|
|
|
|
|
Data.Position = 0;
|
|
|
|
|
}
|
2014-07-30 22:36:35 +12:00
|
|
|
|
|
|
|
|
|
return true;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-30 22:36:35 +12:00
|
|
|
|
private bool DoAfterCaptureJobs()
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-08-17 09:51:18 +12:00
|
|
|
|
if (tempImage == null)
|
|
|
|
|
{
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2017-10-15 02:13:24 +13:00
|
|
|
|
tempImage = TaskHelpers.AddImageEffects(tempImage, Info.TaskSettings.ImageSettingsReference);
|
2016-03-18 22:00:51 +13:00
|
|
|
|
|
|
|
|
|
if (tempImage == null)
|
|
|
|
|
{
|
|
|
|
|
DebugHelper.WriteLine("Error: Applying image effects resulted empty image.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2017-12-27 00:46:29 +13:00
|
|
|
|
tempImage = TaskHelpers.AnnotateImage(tempImage, Info.FileName, Info.TaskSettings, true);
|
2014-07-30 22:36:35 +12:00
|
|
|
|
|
|
|
|
|
if (tempImage == null)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
ClipboardHelpers.CopyImage(tempImage);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
DebugHelper.WriteLine("Image copied to clipboard.");
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-09-26 17:58:04 +12:00
|
|
|
|
TaskHelpers.PrintImage(tempImage);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 11:43:33 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog, AfterCaptureTasks.DoOCR,
|
|
|
|
|
AfterCaptureTasks.UploadImageToHost))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
using (tempImage)
|
|
|
|
|
{
|
|
|
|
|
ImageData imageData = TaskHelpers.PrepareImage(tempImage, Info.TaskSettings);
|
|
|
|
|
Data = imageData.ImageStream;
|
|
|
|
|
Info.FileName = Path.ChangeExtension(Info.FileName, imageData.ImageFormat.GetDescription());
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-04-01 01:20:12 +13:00
|
|
|
|
string filePath = TaskHelpers.CheckFilePath(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
|
2014-03-13 22:31:03 +13:00
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(filePath))
|
|
|
|
|
{
|
|
|
|
|
Info.FilePath = filePath;
|
|
|
|
|
imageData.Write(Info.FilePath);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
DebugHelper.WriteLine("Image saved to file: " + Info.FilePath);
|
2014-03-13 22:31:03 +13:00
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
using (SaveFileDialog sfd = new SaveFileDialog())
|
|
|
|
|
{
|
2015-12-10 07:32:26 +13:00
|
|
|
|
bool imageSaved;
|
2014-04-23 09:55:49 +12:00
|
|
|
|
|
2015-11-01 05:01:49 +13:00
|
|
|
|
do
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2015-11-01 05:01:49 +13:00
|
|
|
|
if (string.IsNullOrEmpty(lastSaveAsFolder) || !Directory.Exists(lastSaveAsFolder))
|
|
|
|
|
{
|
|
|
|
|
lastSaveAsFolder = Info.TaskSettings.CaptureFolder;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sfd.InitialDirectory = lastSaveAsFolder;
|
|
|
|
|
sfd.FileName = Info.FileName;
|
|
|
|
|
sfd.DefaultExt = Path.GetExtension(Info.FileName).Substring(1);
|
|
|
|
|
sfd.Filter = string.Format("*{0}|*{0}|All files (*.*)|*.*", Path.GetExtension(Info.FileName));
|
|
|
|
|
sfd.Title = Resources.UploadTask_DoAfterCaptureJobs_Choose_a_folder_to_save + " " + Path.GetFileName(Info.FileName);
|
|
|
|
|
|
|
|
|
|
if (sfd.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(sfd.FileName))
|
|
|
|
|
{
|
|
|
|
|
Info.FilePath = sfd.FileName;
|
|
|
|
|
lastSaveAsFolder = Path.GetDirectoryName(Info.FilePath);
|
2015-11-24 08:25:38 +13:00
|
|
|
|
imageSaved = imageData.Write(Info.FilePath);
|
2015-11-01 05:01:49 +13:00
|
|
|
|
|
|
|
|
|
if (imageSaved)
|
|
|
|
|
{
|
|
|
|
|
DebugHelper.WriteLine("Image saved to file with dialog: " + Info.FilePath);
|
2015-11-19 02:07:56 +13:00
|
|
|
|
}
|
2015-11-01 05:01:49 +13:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-11-24 08:25:38 +13:00
|
|
|
|
break;
|
2015-11-01 05:01:49 +13:00
|
|
|
|
}
|
|
|
|
|
} while (!imageSaved);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveThumbnailImageToFile))
|
2014-04-23 08:44:58 +12:00
|
|
|
|
{
|
2014-04-23 09:55:49 +12:00
|
|
|
|
string thumbnailFilename, thumbnailFolder;
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(Info.FilePath))
|
|
|
|
|
{
|
|
|
|
|
thumbnailFilename = Path.GetFileName(Info.FilePath);
|
|
|
|
|
thumbnailFolder = Path.GetDirectoryName(Info.FilePath);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
thumbnailFilename = Info.FileName;
|
|
|
|
|
thumbnailFolder = Info.TaskSettings.CaptureFolder;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Info.ThumbnailFilePath = TaskHelpers.CreateThumbnail(tempImage, thumbnailFolder, thumbnailFilename, Info.TaskSettings);
|
2014-04-23 09:00:41 +12:00
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(Info.ThumbnailFilePath))
|
|
|
|
|
{
|
2015-08-17 12:01:10 +12:00
|
|
|
|
DebugHelper.WriteLine("Thumbnail saved to file: " + Info.ThumbnailFilePath);
|
2014-04-23 09:00:41 +12:00
|
|
|
|
}
|
2014-04-23 08:44:58 +12:00
|
|
|
|
}
|
2014-06-05 03:20:13 +12:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-07-30 22:36:35 +12:00
|
|
|
|
|
|
|
|
|
return true;
|
2014-06-05 03:20:13 +12:00
|
|
|
|
}
|
2014-04-23 08:44:58 +12:00
|
|
|
|
|
2014-06-05 03:20:13 +12:00
|
|
|
|
private void DoFileJobs()
|
|
|
|
|
{
|
|
|
|
|
if (!string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
|
|
|
|
|
{
|
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.PerformActions) && Info.TaskSettings.ExternalPrograms != null)
|
|
|
|
|
{
|
2016-09-17 19:07:02 +12:00
|
|
|
|
IEnumerable<ExternalProgram> actions = Info.TaskSettings.ExternalPrograms.Where(x => x.IsActive);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2014-06-05 03:20:13 +12:00
|
|
|
|
if (actions.Count() > 0)
|
|
|
|
|
{
|
|
|
|
|
if (Data != null)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-06-05 03:20:13 +12:00
|
|
|
|
Data.Dispose();
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2014-06-05 03:20:13 +12:00
|
|
|
|
foreach (ExternalProgram fileAction in actions)
|
|
|
|
|
{
|
2015-09-30 21:28:54 +13:00
|
|
|
|
Info.FilePath = fileAction.Run(Info.FilePath);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2014-06-05 03:20:13 +12:00
|
|
|
|
|
2015-08-17 12:01:10 +12:00
|
|
|
|
LoadFileStream();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-03-08 14:33:43 +13:00
|
|
|
|
|
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFileToClipboard))
|
|
|
|
|
{
|
|
|
|
|
ClipboardHelpers.CopyFile(Info.FilePath);
|
|
|
|
|
}
|
|
|
|
|
else if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard))
|
|
|
|
|
{
|
|
|
|
|
ClipboardHelpers.CopyText(Info.FilePath);
|
|
|
|
|
}
|
2016-01-20 12:11:17 +13:00
|
|
|
|
|
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.ShowInExplorer))
|
|
|
|
|
{
|
2016-01-20 22:27:37 +13:00
|
|
|
|
Helpers.OpenFolderWithFile(Info.FilePath);
|
2016-01-20 12:11:17 +13:00
|
|
|
|
}
|
2018-04-04 06:21:41 +12:00
|
|
|
|
|
|
|
|
|
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.ScanQRCode) && Info.DataType == EDataType.Image)
|
|
|
|
|
{
|
|
|
|
|
QRCodeForm.DecodeFile(Info.FilePath).ShowDialog();
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-27 03:42:14 +12:00
|
|
|
|
private void DoTextJobs()
|
|
|
|
|
{
|
|
|
|
|
if (Info.TaskSettings.AdvancedSettings.TextTaskSaveAsFile)
|
|
|
|
|
{
|
|
|
|
|
string filePath = TaskHelpers.CheckFilePath(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(filePath))
|
|
|
|
|
{
|
|
|
|
|
Info.FilePath = filePath;
|
2016-02-22 12:15:23 +13:00
|
|
|
|
Helpers.CreateDirectoryFromFilePath(Info.FilePath);
|
2015-07-27 03:42:14 +12:00
|
|
|
|
File.WriteAllText(Info.FilePath, tempText, Encoding.UTF8);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
DebugHelper.WriteLine("Text saved to file: " + Info.FilePath);
|
2015-07-27 03:42:14 +12:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte[] byteArray = Encoding.UTF8.GetBytes(tempText);
|
|
|
|
|
Data = new MemoryStream(byteArray);
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
private void DoAfterUploadJobs()
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
2015-06-10 06:26:11 +12:00
|
|
|
|
if (Info.TaskSettings.AdvancedSettings.ResultForceHTTPS)
|
|
|
|
|
{
|
2016-12-07 09:33:19 +13:00
|
|
|
|
Info.Result.ForceHTTPS();
|
2015-06-10 06:26:11 +12:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-08 04:02:32 +12:00
|
|
|
|
if (Info.Job != TaskJob.ShareURL && (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.UseURLShortener) || Info.Job == TaskJob.ShortenURL ||
|
|
|
|
|
(Info.TaskSettings.AdvancedSettings.AutoShortenURLLength > 0 && Info.Result.URL.Length > Info.TaskSettings.AdvancedSettings.AutoShortenURLLength)))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
UploadResult result = ShortenURL(Info.Result.URL);
|
|
|
|
|
|
|
|
|
|
if (result != null)
|
|
|
|
|
{
|
|
|
|
|
Info.Result.ShortenedURL = result.ShortenedURL;
|
2016-04-06 00:17:56 +12:00
|
|
|
|
Info.Result.Errors.AddRange(result.Errors);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-11 13:52:53 +12:00
|
|
|
|
if (Info.Job != TaskJob.ShortenURL && (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShareURL) || Info.Job == TaskJob.ShareURL))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-04-06 00:17:56 +12:00
|
|
|
|
UploadResult result = ShareURL(Info.Result.ToString());
|
|
|
|
|
|
|
|
|
|
if (result != null)
|
|
|
|
|
{
|
|
|
|
|
Info.Result.Errors.AddRange(result.Errors);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (Info.Job == TaskJob.ShareURL)
|
|
|
|
|
{
|
|
|
|
|
Info.Result.IsURLExpected = false;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
|
|
|
|
string txt;
|
|
|
|
|
|
2014-05-11 23:47:37 +12:00
|
|
|
|
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.ClipboardContentFormat))
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2014-05-11 23:47:37 +12:00
|
|
|
|
txt = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.ClipboardContentFormat);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
txt = Info.Result.ToString();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(txt))
|
|
|
|
|
{
|
|
|
|
|
ClipboardHelpers.CopyText(txt);
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-05-21 09:49:31 +12:00
|
|
|
|
|
2014-06-11 12:47:20 +12:00
|
|
|
|
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.OpenURL))
|
|
|
|
|
{
|
2014-06-26 11:14:39 +12:00
|
|
|
|
string result;
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.OpenURLFormat))
|
|
|
|
|
{
|
|
|
|
|
result = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.OpenURLFormat);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
result = Info.Result.ToString();
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-28 12:22:56 +12:00
|
|
|
|
URLHelpers.OpenURL(result);
|
2014-06-11 12:47:20 +12:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-21 09:49:31 +12:00
|
|
|
|
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShowQRCode))
|
|
|
|
|
{
|
|
|
|
|
threadWorker.InvokeAsync(() => new QRCodeForm(Info.Result.ToString()).Show());
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
catch (Exception e)
|
|
|
|
|
{
|
|
|
|
|
DebugHelper.WriteException(e);
|
2016-04-04 21:12:21 +12:00
|
|
|
|
AddErrorMessage(e.ToString());
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:53:11 +12:00
|
|
|
|
public UploadResult UploadData(IGenericUploaderService service, Stream stream, string fileName)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-04-04 21:53:11 +12:00
|
|
|
|
if (!service.CheckConfig(Program.UploadersConfig))
|
2016-04-04 21:12:21 +12:00
|
|
|
|
{
|
2016-04-04 21:53:11 +12:00
|
|
|
|
return GetInvalidConfigResult(service);
|
2016-04-04 21:12:21 +12:00
|
|
|
|
}
|
|
|
|
|
|
2016-04-15 12:25:08 +12:00
|
|
|
|
uploader = service.CreateUploader(Program.UploadersConfig, taskReferenceHelper);
|
2016-03-22 09:26:47 +13:00
|
|
|
|
|
2016-04-04 21:53:11 +12:00
|
|
|
|
if (uploader != null)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-04-04 21:53:11 +12:00
|
|
|
|
uploader.BufferSize = (int)Math.Pow(2, Program.Settings.BufferSizePower) * 1024;
|
2017-10-17 04:01:58 +13:00
|
|
|
|
|
|
|
|
|
if (Program.Settings.VerboseRequestLogs)
|
|
|
|
|
{
|
|
|
|
|
uploader.VerboseLogs = true;
|
|
|
|
|
uploader.VerboseLogsPath = Program.RequestLogsFilePath;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:53:11 +12:00
|
|
|
|
uploader.ProgressChanged += uploader_ProgressChanged;
|
|
|
|
|
|
|
|
|
|
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard) && Info.TaskSettings.AdvancedSettings.EarlyCopyURL)
|
|
|
|
|
{
|
|
|
|
|
uploader.EarlyURLCopyRequested += url => ClipboardHelpers.CopyText(url);
|
|
|
|
|
}
|
2016-03-23 05:11:01 +13:00
|
|
|
|
|
2018-07-14 13:13:16 +12:00
|
|
|
|
fileName = URLHelpers.RemoveBidiControlCharacters(fileName);
|
|
|
|
|
|
2018-04-25 11:29:44 +12:00
|
|
|
|
if (Info.TaskSettings.UploadSettings.FileUploadReplaceProblematicCharacters)
|
|
|
|
|
{
|
2018-07-14 18:10:06 +12:00
|
|
|
|
fileName = URLHelpers.ReplaceReservedCharacters(fileName, "_");
|
2018-04-25 11:29:44 +12:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-31 00:00:12 +12:00
|
|
|
|
Info.UploadDuration = Stopwatch.StartNew();
|
|
|
|
|
|
|
|
|
|
UploadResult result = uploader.Upload(stream, fileName);
|
|
|
|
|
|
|
|
|
|
Info.UploadDuration.Stop();
|
|
|
|
|
|
|
|
|
|
return result;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-28 23:05:56 +13:00
|
|
|
|
private bool CheckUploadFilters(Stream stream, string filename)
|
|
|
|
|
{
|
2016-11-09 11:47:59 +13:00
|
|
|
|
if (Info.TaskSettings.UploadSettings.UploaderFilters != null && !string.IsNullOrEmpty(filename) && stream != null)
|
2016-10-28 23:05:56 +13:00
|
|
|
|
{
|
|
|
|
|
UploaderFilter filter = Info.TaskSettings.UploadSettings.UploaderFilters.FirstOrDefault(x => x.IsValidFilter(filename, stream));
|
|
|
|
|
|
|
|
|
|
if (filter != null)
|
|
|
|
|
{
|
|
|
|
|
IGenericUploaderService service = filter.GetUploaderService();
|
|
|
|
|
|
|
|
|
|
if (service != null)
|
|
|
|
|
{
|
|
|
|
|
Info.Result = UploadData(service, stream, filename);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:53:11 +12:00
|
|
|
|
public UploadResult UploadImage(Stream stream, string fileName)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-04-15 12:25:08 +12:00
|
|
|
|
ImageUploaderService service = UploaderFactory.ImageUploaderServices[Info.TaskSettings.ImageDestination];
|
2016-04-05 02:53:11 +12:00
|
|
|
|
|
|
|
|
|
return UploadData(service, stream, fileName);
|
2016-04-04 21:53:11 +12:00
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
|
2016-04-04 21:53:11 +12:00
|
|
|
|
public UploadResult UploadText(Stream stream, string fileName)
|
|
|
|
|
{
|
2016-04-15 12:25:08 +12:00
|
|
|
|
TextUploaderService service = UploaderFactory.TextUploaderServices[Info.TaskSettings.TextDestination];
|
2016-04-05 02:53:11 +12:00
|
|
|
|
|
|
|
|
|
return UploadData(service, stream, fileName);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public UploadResult UploadFile(Stream stream, string fileName)
|
|
|
|
|
{
|
2016-04-15 12:25:08 +12:00
|
|
|
|
FileUploaderService service = UploaderFactory.FileUploaderServices[Info.TaskSettings.GetFileDestinationByDataType(Info.DataType)];
|
2016-04-05 02:53:11 +12:00
|
|
|
|
|
|
|
|
|
return UploadData(service, stream, fileName);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public UploadResult ShortenURL(string url)
|
|
|
|
|
{
|
2016-04-15 12:25:08 +12:00
|
|
|
|
URLShortenerService service = UploaderFactory.URLShortenerServices[Info.TaskSettings.URLShortenerDestination];
|
2016-04-05 02:53:11 +12:00
|
|
|
|
|
|
|
|
|
if (!service.CheckConfig(Program.UploadersConfig))
|
|
|
|
|
{
|
|
|
|
|
return GetInvalidConfigResult(service);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
URLShortener urlShortener = service.CreateShortener(Program.UploadersConfig, taskReferenceHelper);
|
2013-12-21 04:59:26 +13:00
|
|
|
|
|
2016-03-23 08:24:26 +13:00
|
|
|
|
if (urlShortener != null)
|
2016-03-22 13:26:04 +13:00
|
|
|
|
{
|
2016-03-23 08:24:26 +13:00
|
|
|
|
return urlShortener.ShortenURL(url);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-06 00:17:56 +12:00
|
|
|
|
public UploadResult ShareURL(string url)
|
2014-06-15 22:29:09 +12:00
|
|
|
|
{
|
2016-03-24 07:47:59 +13:00
|
|
|
|
if (!string.IsNullOrEmpty(url))
|
|
|
|
|
{
|
2016-04-15 12:25:08 +12:00
|
|
|
|
URLSharingService service = UploaderFactory.URLSharingServices[Info.TaskSettings.URLSharingServiceDestination];
|
2016-04-05 02:53:11 +12:00
|
|
|
|
|
2016-04-06 00:17:56 +12:00
|
|
|
|
if (!service.CheckConfig(Program.UploadersConfig))
|
2016-04-05 02:53:11 +12:00
|
|
|
|
{
|
2016-04-06 00:17:56 +12:00
|
|
|
|
return GetInvalidConfigResult(service);
|
2016-04-05 02:53:11 +12:00
|
|
|
|
}
|
2016-04-06 00:17:56 +12:00
|
|
|
|
|
2017-09-10 22:55:21 +12:00
|
|
|
|
URLSharer urlSharer = service.CreateSharer(Program.UploadersConfig, taskReferenceHelper);
|
2016-04-06 00:17:56 +12:00
|
|
|
|
|
2017-09-10 22:55:21 +12:00
|
|
|
|
if (urlSharer != null)
|
|
|
|
|
{
|
|
|
|
|
return urlSharer.ShareURL(url);
|
|
|
|
|
}
|
2016-03-24 07:47:59 +13:00
|
|
|
|
}
|
2016-04-06 00:17:56 +12:00
|
|
|
|
|
|
|
|
|
return null;
|
2014-06-15 22:29:09 +12:00
|
|
|
|
}
|
|
|
|
|
|
2016-04-04 21:12:21 +12:00
|
|
|
|
private UploadResult GetInvalidConfigResult(IUploaderService uploaderService)
|
|
|
|
|
{
|
|
|
|
|
UploadResult ur = new UploadResult();
|
2016-07-13 13:14:54 +12:00
|
|
|
|
|
|
|
|
|
string message = string.Format(Resources.WorkerTask_GetInvalidConfigResult__0__configuration_is_invalid_or_missing__Please_check__Destination_settings__window_to_configure_it_,
|
|
|
|
|
uploaderService.ServiceName);
|
2016-04-05 23:03:05 +12:00
|
|
|
|
DebugHelper.WriteLine(message);
|
|
|
|
|
ur.Errors.Add(message);
|
2016-04-30 10:26:49 +12:00
|
|
|
|
|
|
|
|
|
OnUploadersConfigWindowRequested(uploaderService);
|
|
|
|
|
|
2016-04-04 21:12:21 +12:00
|
|
|
|
return ur;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-20 12:54:17 +12:00
|
|
|
|
private bool DownloadFromURL(bool upload)
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
|
|
|
|
string url = Info.Result.URL.Trim();
|
2016-05-25 06:15:45 +12:00
|
|
|
|
Info.Result.URL = "";
|
2015-08-29 18:11:37 +12:00
|
|
|
|
Info.FilePath = TaskHelpers.CheckFilePath(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
|
2015-08-29 18:11:37 +12:00
|
|
|
|
if (!string.IsNullOrEmpty(Info.FilePath))
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
2015-08-29 18:11:37 +12:00
|
|
|
|
Info.Status = Resources.UploadTask_DownloadAndUpload_Downloading;
|
|
|
|
|
OnStatusChanged();
|
2015-08-17 12:01:10 +12:00
|
|
|
|
|
2015-08-29 18:11:37 +12:00
|
|
|
|
try
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
2016-02-22 12:15:23 +13:00
|
|
|
|
Helpers.CreateDirectoryFromFilePath(Info.FilePath);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
|
2015-08-29 18:11:37 +12:00
|
|
|
|
using (WebClient wc = new WebClient())
|
2015-08-17 12:01:10 +12:00
|
|
|
|
{
|
2017-03-12 10:35:18 +13:00
|
|
|
|
wc.Headers.Add(HttpRequestHeader.UserAgent, ShareXResources.UserAgent);
|
2015-08-29 18:11:37 +12:00
|
|
|
|
wc.Proxy = HelpersOptions.CurrentProxy.GetWebProxy();
|
|
|
|
|
wc.DownloadFile(url, Info.FilePath);
|
|
|
|
|
}
|
2015-08-17 12:01:10 +12:00
|
|
|
|
|
2016-07-20 12:54:17 +12:00
|
|
|
|
if (upload)
|
|
|
|
|
{
|
|
|
|
|
LoadFileStream();
|
|
|
|
|
}
|
2015-08-17 12:01:10 +12:00
|
|
|
|
|
2015-08-29 18:11:37 +12:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
catch (Exception e)
|
|
|
|
|
{
|
|
|
|
|
DebugHelper.WriteException(e);
|
|
|
|
|
MessageBox.Show(string.Format(Resources.UploadManager_DownloadAndUploadFile_Download_failed, e), "ShareX", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
2015-08-17 12:01:10 +12:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 11:43:33 +12:00
|
|
|
|
private void DoOCR()
|
|
|
|
|
{
|
|
|
|
|
if (Data != null && Info.DataType == EDataType.Image)
|
|
|
|
|
{
|
2016-12-13 01:19:02 +13:00
|
|
|
|
TaskHelpers.OCRImage(Data, Info.FileName);
|
2016-05-13 11:43:33 +12:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-17 12:01:10 +12:00
|
|
|
|
private bool LoadFileStream()
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
Data = new FileStream(Info.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
|
|
|
|
|
}
|
|
|
|
|
catch (Exception e)
|
|
|
|
|
{
|
2017-04-22 08:42:52 +12:00
|
|
|
|
e.ShowError();
|
2015-08-17 12:01:10 +12:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
private void ThreadCompleted()
|
|
|
|
|
{
|
2016-05-18 01:43:04 +12:00
|
|
|
|
OnTaskCompleted();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void uploader_ProgressChanged(ProgressManager progress)
|
|
|
|
|
{
|
|
|
|
|
if (progress != null)
|
|
|
|
|
{
|
|
|
|
|
Info.Progress = progress;
|
|
|
|
|
|
2016-04-30 10:26:49 +12:00
|
|
|
|
OnUploadProgressChanged();
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void OnStatusChanged()
|
|
|
|
|
{
|
|
|
|
|
if (StatusChanged != null)
|
|
|
|
|
{
|
2016-04-30 10:26:49 +12:00
|
|
|
|
threadWorker.InvokeAsync(() => StatusChanged(this));
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void OnUploadStarted()
|
|
|
|
|
{
|
|
|
|
|
if (UploadStarted != null)
|
|
|
|
|
{
|
2016-04-30 10:26:49 +12:00
|
|
|
|
threadWorker.InvokeAsync(() => UploadStarted(this));
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-31 00:00:12 +12:00
|
|
|
|
private void OnUploadCompleted()
|
|
|
|
|
{
|
|
|
|
|
if (UploadCompleted != null)
|
|
|
|
|
{
|
|
|
|
|
threadWorker.InvokeAsync(() => UploadCompleted(this));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
private void OnUploadProgressChanged()
|
|
|
|
|
{
|
|
|
|
|
if (UploadProgressChanged != null)
|
|
|
|
|
{
|
2016-04-30 10:26:49 +12:00
|
|
|
|
threadWorker.InvokeAsync(() => UploadProgressChanged(this));
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-18 01:43:04 +12:00
|
|
|
|
private void OnTaskCompleted()
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2017-06-12 08:01:11 +12:00
|
|
|
|
Info.TaskEndTime = DateTime.Now;
|
2016-05-31 00:00:12 +12:00
|
|
|
|
|
2014-06-09 04:36:47 +12:00
|
|
|
|
if (StopRequested)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2018-06-11 05:39:48 +12:00
|
|
|
|
Status = TaskStatus.Stopped;
|
2014-10-17 22:58:15 +13:00
|
|
|
|
Info.Status = Resources.UploadTask_OnUploadCompleted_Stopped;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
2018-06-11 05:39:48 +12:00
|
|
|
|
else if (Info.Result.IsError)
|
|
|
|
|
{
|
|
|
|
|
Status = TaskStatus.Failed;
|
|
|
|
|
Info.Status = Resources.TaskManager_task_UploadCompleted_Error;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
else
|
|
|
|
|
{
|
2018-06-11 05:39:48 +12:00
|
|
|
|
Status = TaskStatus.Completed;
|
2014-10-17 22:58:15 +13:00
|
|
|
|
Info.Status = Resources.UploadTask_OnUploadCompleted_Done;
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-18 01:43:04 +12:00
|
|
|
|
if (TaskCompleted != null)
|
2013-11-03 23:53:49 +13:00
|
|
|
|
{
|
2016-05-18 01:43:04 +12:00
|
|
|
|
TaskCompleted(this);
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-30 10:26:49 +12:00
|
|
|
|
private void OnUploadersConfigWindowRequested(IUploaderService uploaderService)
|
|
|
|
|
{
|
|
|
|
|
if (UploadersConfigWindowRequested != null)
|
|
|
|
|
{
|
|
|
|
|
threadWorker.InvokeAsync(() => UploadersConfigWindowRequested(uploaderService));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-03 23:53:49 +13:00
|
|
|
|
public void Dispose()
|
|
|
|
|
{
|
2014-07-19 07:13:32 +12:00
|
|
|
|
if (Data != null)
|
|
|
|
|
{
|
|
|
|
|
Data.Dispose();
|
|
|
|
|
Data = null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (tempImage != null)
|
|
|
|
|
{
|
|
|
|
|
tempImage.Dispose();
|
|
|
|
|
tempImage = null;
|
|
|
|
|
}
|
2013-11-03 23:53:49 +13:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-03-18 22:00:51 +13:00
|
|
|
|
}
|