public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
switch (data.DataType) {
case TypedDataType.Stream:
progress.Status = "Saving to file";
string path = Path.Combine(RootPath ?? "", data.Name);
using (var file = File.Open(path, FileMode.Create, FileAccess.Write)) {
var inputStream = (Stream) data.Data;
CopyStream(inputStream, file, progress);
var uriBuilder = new UriBuilder {
Scheme = Uri.UriSchemeFile,
Path = path
};
return TypedData.FromUri(uriBuilder.Uri, "output file");
}
default:
return null;
}
}
public override TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
switch (data.DataType) {
case TypedDataType.Image:
var rawImageProgress = new MutableProgressTracker();
var uploadProgress = new MutableProgressTracker();
var aggregateProgress = new AggregateProgressTracker(new ProgressTrackerCollection {
{ rawImageProgress, ImageWriter.ProcessTimeEstimate.ProgressWeight },
{ uploadProgress, ProcessTimeEstimate.ProgressWeight },
});
aggregateProgress.BindTo(progress);
progress.Status = "Converting image";
using (var rawImageData = ImageWriter.Process(data, rawImageProgress, cancelToken)) {
progress.Status = "Uploading image";
return Upload(rawImageData, uploadProgress, cancelToken);
}
default:
return null;
}
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
progress.Status = "Taking a crop shot";
CropShotWindow cropShotWindow = null;
var thread = new Thread(() => {
cropShotWindow = new CropShotWindow {
SourceImage = (Image) data.Data,
DataName = data.Name
};
cropShotWindow.ShowDialog();
});
// UI objects want to be in STA; make sure we're in STA
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
if (cropShotWindow.Data == null) {
throw new CommandCanceledException(this);
}
progress.Progress = 1;
return cropShotWindow.Data;
}
public static void BindTo(this IProgressTracker from, IMutableProgressTracker to)
{
from.ProgressUpdated += (sender, e) => {
to.Progress = e.Progress;
};
from.StatusUpdated += (sender, e) => {
to.Status = e.Status;
};
}
public TypedData Upload(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
try {
var response = HttpRequest.Execute(Uri, GetRequestData(data), RequestMethod, progress, cancelToken);
return GetResponseData(response, data);
} catch (OperationCanceledException e) {
throw CommandCanceledException.Wrap(e, this);
}
}
protected override Stream Encode(Bitmap image, IMutableProgressTracker progress, CancellationToken cancelToken)
{
var stream = new MemoryStream();
var encoder = ImageCodecInfo.GetImageEncoders().First((enc) => enc.FormatID.Equals(EncoderFormat.Guid));
image.Save(stream, encoder, null);
stream.Position = 0;
progress.Progress = 1;
return stream;
}
public override TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
switch (data.DataType) {
case TypedDataType.Text:
progress.Status = "Uploading text";
return Upload(data, progress, cancelToken);
default:
return null;
}
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
switch (data.DataType) {
case TypedDataType.Image:
return TypedData.FromStream(Encode((Bitmap) data.Data, progress, cancelToken), data.Name);
case TypedDataType.Stream:
return TypedData.FromImage(Decode((Stream) data.Data, progress, cancelToken), data.Name);
default:
throw new NotSupportedException();
}
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
switch (SourceType) {
case ScreenshotSourceType.EntireDesktop:
var image = ScreenCapturer.CaptureEntireDesktop();
progress.Progress = 1; // Can't really track progress on this...
return TypedData.FromImage(image, "screenshot");
default:
return null;
}
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
Action operation;
bool success = false;
Exception exception = null;
if (data == null) {
operation = new Action(() => {
progress.Status = "Reading clipboard";
try {
data = GetClipboardData();
success = true;
} catch (Exception e) {
exception = e;
}
});
} else {
operation = new Action(() => {
progress.Status = "Saving to clipboard";
try {
SetClipboardData(data);
success = true;
} catch (Exception e) {
exception = e;
}
});
}
var thread = new Thread(new ThreadStart(operation));
// Clipboard object uses COM; make sure we're in STA
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
if (!success) {
if (exception == null) {
throw new CommandCanceledException(this);
}
throw exception;
}
progress.Progress = 1;
return data;
}
public static HttpWebResponse Execute(Uri uri, Stream requestData, IMutableProgressTracker progress, CancellationToken cancelToken)
{
// QUICK HACK
var requestProgress = new MutableProgressTracker();
var responseProgress = new MutableProgressTracker();
var aggregateProgress = new AggregateProgressTracker(new ProgressTrackerCollection {
{ requestProgress, TimeEstimates.LongOperation.ProgressWeight },
{ responseProgress, TimeEstimates.ShortOperation.ProgressWeight },
});
aggregateProgress.BindTo(progress);
try {
var request = CreateRequest(uri, @"POST");
request.ContentLength = requestData.Length;
using (var requestStream = request.GetRequestStream())
using (var progressStream = new ProgressTrackingStreamWrapper(requestStream, request.ContentLength)) {
progressStream.BindTo(requestProgress);
requestData.CopyTo(progressStream, cancelToken);
}
bool canCancel = true;
cancelToken.Register(() => {
if (canCancel) {
request.Abort();
}
});
var response = (HttpWebResponse) request.GetResponse();
responseProgress.Progress = 1; // TODO HTTP download Progress
canCancel = false;
return response;
} catch (WebException e) {
if (e.Status == WebExceptionStatus.RequestCanceled) {
throw new OperationCanceledException(e.Message, e, cancelToken);
}
throw new OperationCanceledException(e.Message, e, cancelToken);
}
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
if (data.DataType != TypedDataType.Image) {
throw new ArgumentException("data must be an image", "data");
}
if (!IsCodecValid(Codec)) {
throw new InvalidOperationException("Codec must be non-null and support bitmap encoding");
}
// No dispose
var processedImage = Codec.Process(data, progress, cancelToken);
var name = processedImage.Name;
return new TypedData(processedImage.DataType, processedImage.Data, GetDataName(name));
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
// ToList is needed to prevent new MPT's from being
// created for each loop of commandProgressTrackers
var commandProgressTrackers = this.commands.Select((command) => new {
ProgressTracker = new MutableProgressTracker(),
Command = command
}).ToList();
var aggregateProgress = new AggregateProgressTracker(commandProgressTrackers.Select(
(cpt) => new ProgressTrackerCollectionItem(
cpt.ProgressTracker,
cpt.Command.ProcessTimeEstimate.ProgressWeight
)
));
aggregateProgress.BindTo(progress);
bool shouldDisposeData = false;
foreach (var cpt in commandProgressTrackers) {
cancelToken.ThrowIfCancellationRequested();
TypedData newData;
try {
cancelToken.ThrowIfCancellationRequested();
if (!cpt.Command.IsValid()) {
throw new CommandInvalidException(cpt.Command);
}
newData = cpt.Command.Process(data, cpt.ProgressTracker, cancelToken);
cancelToken.ThrowIfCancellationRequested();
} finally {
if (shouldDisposeData && data != null) {
data.Dispose();
}
}
data = newData;
shouldDisposeData = true;
}
return data;
}
private CommandTask(ICommand command, CancellationTokenSource cancellationTokenSource, bool ownsCancellationTokenSource)
{
if (command == null) {
throw new ArgumentNullException("command");
}
if (cancellationTokenSource == null) {
throw new ArgumentNullException("cancellationTokenSource");
}
this.command = command;
this.cancellationTokenSource = cancellationTokenSource;
this.ownsCancellationTokenSource = ownsCancellationTokenSource;
this.progressTracker = new MutableProgressTracker();
this.publicProgressTracker = new ReadOnlyProgressTracker(this.progressTracker);
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
progress.Status = "Uploading data";
var galleryProgress = new MutableProgressTracker();
var uploadProgress = new MutableProgressTracker();
var aggregateProgress = new AggregateProgressTracker(new ProgressTrackerCollection {
{ galleryProgress, TimeEstimates.ShortOperation.ProgressWeight },
{ uploadProgress, TimeEstimates.LongOperation.ProgressWeight },
});
aggregateProgress.BindTo(progress);
var galleryAccessData = CreateGallery(galleryProgress, cancelToken);
return UploadData(galleryAccessData, data, uploadProgress, cancelToken);
}
public override void Execute(IMutableProgressTracker progress, CancellationToken cancelToken)
{
var commandChain = new CommandChain(
new Screenshot(),
Renamer,
new CropShot(),
ImageUploader,
new Clipboard()
);
using (commandChain.Process(null, progress, cancelToken)) {
// Auto-dispose
}
progress.Status = "Image URL saved to clipboard";
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
return new CommandChain(ImageWriter, FileUploader).Process(data, progress, cancelToken);
}
private void UploadData(Stream stream, string fileName, IMutableProgressTracker progress, CancellationToken cancelToken)
{
using (var client = new FTPSClient()) {
try {
progress.Status = "Connecting to FTP";
client.Connect(Host, Port, new NetworkCredential(UserName, Password), 0, null, null, 0, 0, 0, Timeout);
} catch (TimeoutException e) {
throw new CommandCanceledException(this, "Connection to FTP server timed out", e);
} catch (IOException e) {
throw new CommandCanceledException(this, "Connection to FTP server failed", e);
}
using (var outStream = client.PutFile(GetRemotePathName(fileName)))
using (var outStreamWrapper = new ProgressTrackingStreamWrapper(outStream, stream.Length)) {
outStreamWrapper.BindTo(progress);
progress.Status = "Uploading file to FTP";
stream.CopyTo(outStreamWrapper, cancelToken);
}
}
}
private static string FetchToken(IMutableProgressTracker progress, CancellationToken cancelToken)
{
var response = HttpRequest.Execute(new UriBuilder(ApiUri) {
Query = HttpUtility.ToQueryString(new Dictionary<string, string> {
{ "method", "auth.createtoken" },
{ "api_key", Properties.Settings.Default.sendSpaceApiKey },
{ "api_version", "1.0" },
{ "response_format", "XML" },
{ "app_version", "NoCap" },
}),
}.Uri, null, HttpRequestMethod.Get, progress, cancelToken);
var xmlDoc = GetXml(response);
return xmlDoc.SelectSingleNode("/result/token").InnerText;
}
protected virtual Stream Encode(Bitmap image, IMutableProgressTracker progress, CancellationToken cancelToken)
{
throw new NotSupportedException();
}
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
string fileName = data.Name;
var stream = (Stream) data.Data;
UploadData(stream, fileName, progress, cancelToken);
progress.Progress = 1;
string result;
bool success = TryGetResultString(fileName, out result);
return TypedData.FromUri(new Uri(success && !string.IsNullOrWhiteSpace(result) ? result : data.Name, UriKind.Absolute), fileName);
}
private static Uri FetchUploadUri(string sessionKey, out string uploadId, out string uploadInfo, out ulong maxFileSize, IMutableProgressTracker progress, CancellationToken cancelToken)
{
var response = HttpRequest.Execute(new UriBuilder(ApiUri) {
Query = HttpUtility.ToQueryString(new Dictionary<string, string> {
{ "method", "upload.getInfo" },
{ "session_key", sessionKey },
}),
}.Uri, null, HttpRequestMethod.Get, progress, cancelToken);
var xmlDoc = GetXml(response);
uploadId = xmlDoc.SelectSingleNode("/result/upload/@upload_identifier").InnerText;
uploadInfo = xmlDoc.SelectSingleNode("/result/upload/@extra_info").InnerText;
maxFileSize = ulong.Parse(xmlDoc.SelectSingleNode("/result/upload/@max_file_size").InnerText);
return new Uri(xmlDoc.SelectSingleNode("/result/upload/@url").InnerText, UriKind.Absolute);
}
protected virtual Bitmap Decode(Stream stream, IMutableProgressTracker progress, CancellationToken cancelToken)
{
throw new NotSupportedException();
}
private static Uri UploadData(TypedData data, Uri uri, string uploadId, string uploadInfo, ulong maxFileSize, IMutableProgressTracker progress, CancellationToken cancelToken)
{
var postData = new MultipartDataBuilder()
.KeyValuePair("MAX_FILE_SIZE", maxFileSize.ToString())
.KeyValuePair("UPLOAD_IDENTIFIER", uploadId)
.KeyValuePair("extra_info", uploadInfo)
.File((Stream) data.Data, "userfile", data.Name)
.GetData();
var response = HttpRequest.Execute(uri, postData, HttpRequestMethod.Post, progress, cancelToken);
string text = HttpRequest.GetResponseText(response);
var match = new Regex(@"\bfile_id=(?<FileId>\S+)\b").Match(text);
return new Uri(string.Format(OutputFileUriFormat, match.Groups["FileId"].Value), UriKind.Absolute);
}
private static void CopyStream(Stream inputStream, Stream outputStream, IMutableProgressTracker progress)
{
long originalByteCount;
long bytesProcessed = 0;
try {
originalByteCount = inputStream.Length;
} catch (NotSupportedException) {
// .Length is not supported; length is undefined
originalByteCount = -1;
}
const int bufferSize = 1024;
byte[] readBuffer = new byte[bufferSize];
while (true) {
if (originalByteCount > 0) {
progress.Progress = (double) bytesProcessed / originalByteCount;
}
int bytesRead = inputStream.Read(readBuffer, 0, readBuffer.Length);
outputStream.Write(readBuffer, 0, bytesRead);
bytesProcessed += bufferSize;
if (bytesRead < bufferSize) {
// We hit end-of-file
break;
}
}
progress.Progress = 1;
}
private string FetchSessionKey(string token, IMutableProgressTracker progress, CancellationToken cancelToken)
{
var response = HttpRequest.Execute(new UriBuilder(ApiUri) {
Query = HttpUtility.ToQueryString(new Dictionary<string, string> {
{ "method", "auth.login" },
{ "token", token },
{ "user_name", UserName },
{ "tokened_password", GetTokenedPassword(token, Password) },
}),
}.Uri, null, HttpRequestMethod.Get, progress, cancelToken);
var xmlDoc = GetXml(response);
return xmlDoc.SelectSingleNode("/result/session_key").InnerText;
}
TypedData ICommand.Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
Execute(progress, cancelToken);
return null;
}
public abstract void Execute(IMutableProgressTracker progress, CancellationToken cancelToken);
public TypedData Process(TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken)
{
if (string.IsNullOrEmpty(UserName)) {
throw new InvalidOperationException("User name must be set");
}
if (Password == null) {
throw new InvalidOperationException("Password must be set");
}
var progressTrackerCollection = new ProgressTrackerCollection {
{ new MutableProgressTracker(), 1 },
{ new MutableProgressTracker(), 1 },
{ new MutableProgressTracker(), 2 },
{ new MutableProgressTracker(), 100 },
};
var progressTrackers = progressTrackerCollection.Select((item) => item.ProgressTracker).OfType<IMutableProgressTracker>().ToArray();
var aggregateProgressTracker = new AggregateProgressTracker(progressTrackerCollection);
aggregateProgressTracker.BindTo(progress);
string token = FetchToken(progressTrackers[0], cancelToken);
string sessionKey = FetchSessionKey(token, progressTrackers[1], cancelToken);
string uploadId, uploadInfo;
ulong maxFileSize;
var uploadUri = FetchUploadUri(sessionKey, out uploadId, out uploadInfo, out maxFileSize, progressTrackers[2], cancelToken);
var uri = UploadData(data, uploadUri, uploadId, uploadInfo, maxFileSize, progressTrackers[3], cancelToken);
return TypedData.FromUri(uri, data.Name);
}
public override void Execute(IMutableProgressTracker progress, CancellationToken cancelToken)
{
var clipboard = new Clipboard();
var router = new DataRouter {
{ TypedDataType.Image, ImageUploader },
{ TypedDataType.Text, TextUploader },
{ TypedDataType.Uri, UrlShortener },
{ TypedDataType.Stream, FileUploader },
};
var commandChain = new CommandChain(
clipboard,
router,
clipboard
);
using (commandChain.Process(null, progress, cancelToken)) {
// Auto-dispose
}
progress.Status = "URL saved to clipboard";
}
