public override UploadResult ShareURL(string url)
{
UploadResult result = new UploadResult {
URL = url, IsURLExpected = false
};
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput("", url);
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.URLSharingService);
if (requestFormat == CustomUploaderRequestFormat.FormData)
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(), uploader.GetArguments(input), uploader.GetHeaders(input), null,
uploader.ResponseType, uploader.GetHttpMethod());
}
else if (requestFormat == CustomUploaderRequestFormat.URLQuery)
{
result.Response = SendRequest(uploader.GetHttpMethod(), uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.JSON)
{
result.Response = SendRequest(uploader.GetHttpMethod(), uploader.GetRequestURL(), uploader.GetData(input), UploadHelpers.ContentTypeJSON,
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format.");
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, "");
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.FileUploader);
if (requestFormat == CustomUploaderRequestFormat.MultipartFormData)
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType, uploader.RequestType);
}
else if (requestFormat == CustomUploaderRequestFormat.Binary)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(input), stream, UploadHelpers.GetMimeType(fileName),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format.");
}
try
{
uploader.ParseResponse(result, input);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, text);
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.TextUploader);
if (requestFormat == CustomUploaderRequestFormat.FormData)
{
if (string.IsNullOrEmpty(uploader.FileFormName))
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType, uploader.GetHttpMethod());
}
else
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result = SendRequestFile(uploader.GetRequestURL(), stream, fileName, uploader.GetFileFormName(),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType, uploader.GetHttpMethod());
}
}
}
else if (requestFormat == CustomUploaderRequestFormat.URLQuery)
{
result.Response = SendRequest(uploader.GetHttpMethod(), uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.JSON)
{
result.Response = SendRequest(uploader.GetHttpMethod(), uploader.GetRequestURL(), uploader.GetData(input), UploadHelpers.ContentTypeJSON,
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format.");
}
try
{
uploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult ShortenURL(string url)
{
if (customUploader.RequestType == CustomUploaderRequestType.POST && !string.IsNullOrEmpty(customUploader.FileFormName))
{
throw new Exception("'File form name' cannot be used with custom URL shortener.");
}
if (customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$") || x.Value.Contains("%input")))
{
throw new Exception("Atleast one '$input$' required for argument value.");
}
UploadResult result = new UploadResult {
URL = url
};
Dictionary <string, string> args = customUploader.GetArguments(url);
result.Response = SendRequest(customUploader.GetHttpMethod(), customUploader.GetRequestURL(), args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
try
{
customUploader.ParseResponse(result, true);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult ShareURL(string url)
{
UploadResult result = new UploadResult {
URL = url, IsURLExpected = false
};
CustomUploaderInput input = new CustomUploaderInput("", url);
if (uploader.RequestFormat == CustomUploaderRequestFormat.MultipartFormData)
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input), null,
uploader.ResponseType, uploader.RequestType);
}
else if (uploader.RequestFormat == CustomUploaderRequestFormat.URLQueryString)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(input), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (uploader.RequestFormat == CustomUploaderRequestFormat.JSON)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(input), uploader.GetData(input), UploadHelpers.ContentTypeJSON,
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (uploader.RequestFormat == CustomUploaderRequestFormat.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestType, uploader.GetRequestURL(input), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format: " + uploader.RequestFormat);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (customUploader.RequestType != CustomUploaderRequestType.POST)
{
throw new Exception("'Request type' must be 'POST' when using custom file uploader.");
}
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, "");
UploadResult result = SendRequestFile(customUploader.GetRequestURL(), stream, fileName, customUploader.GetFileFormName(),
customUploader.GetArguments(input), customUploader.GetHeaders(input), responseType: customUploader.ResponseType);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
public override UploadResult ShareURL(string url)
{
if (customUploader.RequestType == CustomUploaderRequestType.POST && !string.IsNullOrEmpty(customUploader.FileFormName))
{
throw new Exception("'File form name' cannot be used with custom URL sharing service.");
}
if (customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$")))
{
throw new Exception("Atleast one '$input$' required for argument value.");
}
UploadResult result = new UploadResult {
URL = url, IsURLExpected = false
};
Dictionary <string, string> args = customUploader.GetArguments(url);
if (customUploader.RequestType == CustomUploaderRequestType.POST)
{
result.Response = SendRequestMultiPart(customUploader.GetRequestURL(), args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
}
else
{
result.Response = SendRequest(customUploader.GetHttpMethod(), customUploader.GetRequestURL(), args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, "");
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.ImageUploader);
if (requestFormat == CustomUploaderRequestFormat.FormData)
{
UploadResult result = SendRequestFile(uploader.GetRequestURL(), stream, fileName, uploader.GetFileFormName(),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType, uploader.GetHttpMethod());
if (result.IsSuccess)
{
try
{
uploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
else
{
throw new Exception("Unsupported request format.");
}
}
public override UploadResult ShortenURL(string url)
{
UploadResult result = new UploadResult {
URL = url
};
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput("", url);
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.URLShortener);
if (requestFormat == CustomUploaderRequestFormat.MultipartFormData)
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(), uploader.GetArguments(input), uploader.GetHeaders(input), null,
uploader.ResponseType, uploader.RequestType);
}
else if (requestFormat == CustomUploaderRequestFormat.URLQueryString)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.JSON)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(), uploader.GetData(input), UploadHelpers.ContentTypeJSON,
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestType, uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format.");
}
try
{
uploader.ParseResponse(result, true);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, "");
if (customUploader.RequestType == CustomUploaderRequestType.POST)
{
UploadResult result = SendRequestFile(customUploader.GetRequestURL(), stream, fileName, customUploader.GetFileFormName(),
customUploader.GetArguments(input), customUploader.GetHeaders(input), responseType: customUploader.ResponseType);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
else if (customUploader.RequestType == CustomUploaderRequestType.PUT)
{
string response = SendRequest(HttpMethod.PUT, URLHelpers.CombineURL(customUploader.GetRequestURL(), fileName), stream, UploadHelpers.GetMimeType(fileName), null, customUploader.GetHeaders(input), null, customUploader.ResponseType);
UploadResult result = new UploadResult();
result.Response = response;
result.IsSuccess = true;
result.URL = URLHelpers.CombineURL(customUploader.URL, fileName);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
else
{
throw new Exception("'Request type' must be 'POST' or 'PUT' when using custom file uploader.");
}
}
public override UploadResult UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
string requestURL = customUploader.GetRequestURL();
if ((customUploader.RequestType != CustomUploaderRequestType.POST || string.IsNullOrEmpty(customUploader.FileFormName)) &&
((customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$"))) &&
(customUploader.Headers == null || !customUploader.Headers.Any(x => x.Value.Contains("$input$")))))
{
throw new Exception("Atleast one '$input$' required for argument or header value.");
}
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, text);
Dictionary <string, string> args = customUploader.GetArguments(input);
if (customUploader.RequestType == CustomUploaderRequestType.POST)
{
if (string.IsNullOrEmpty(customUploader.FileFormName))
{
result.Response = SendRequestMultiPart(requestURL, args, customUploader.GetHeaders(input), responseType: customUploader.ResponseType);
}
else
{
byte[] byteArray = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(byteArray))
{
result = SendRequestFile(requestURL, stream, fileName, customUploader.GetFileFormName(), args, customUploader.GetHeaders(input),
responseType: customUploader.ResponseType);
}
}
}
else
{
result.Response = SendRequest(customUploader.GetHttpMethod(), requestURL, args, customUploader.GetHeaders(input),
responseType: customUploader.ResponseType);
}
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
string requestURL = customUploader.GetRequestURL();
if ((customUploader.RequestType != CustomUploaderRequestType.POST || string.IsNullOrEmpty(customUploader.FileFormName)) &&
(customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$") || x.Value.Contains("%input"))))
{
throw new Exception("Atleast one '$input$' required for argument value.");
}
Dictionary <string, string> args = customUploader.GetArguments(text);
if (customUploader.RequestType == CustomUploaderRequestType.POST)
{
if (string.IsNullOrEmpty(customUploader.FileFormName))
{
result.Response = SendRequest(HttpMethod.POST, requestURL, args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
}
else
{
byte[] byteArray = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(byteArray))
{
result = UploadData(stream, requestURL, fileName, customUploader.GetFileFormName(), args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
}
}
}
else
{
result.Response = SendRequest(customUploader.GetHttpMethod(), requestURL, args, customUploader.GetHeaders(), responseType: customUploader.ResponseType);
}
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
// TODO: Translate
Errors.Add("Response parse failed." + Environment.NewLine + e);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, "");
UploadResult result = SendRequestFile(customUploader.GetRequestURL(), stream, fileName, customUploader.GetFileFormName(),
customUploader.GetArguments(input), customUploader.GetHeaders(input), null, customUploader.ResponseType, customUploader.GetHttpMethod());
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
public override UploadResult UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, text);
if (uploader.Body == CustomUploaderBody.None)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), null, uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
if (string.IsNullOrEmpty(uploader.FileFormName))
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input),
null, uploader.RequestMethod);
}
else
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.RequestMethod);
}
}
}
else if (uploader.Body == CustomUploaderBody.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.JSON || uploader.Body == CustomUploaderBody.XML)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetData(input), uploader.GetContentType(),
null, uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.Binary)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), stream, RequestHelpers.GetMimeType(fileName),
null, uploader.GetHeaders(input));
}
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
try
{
uploader.ParseResponse(result, LastResponseInfo, input);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult ShareURL(string url)
{
UploadResult result = new UploadResult {
URL = url, IsURLExpected = false
};
CustomUploaderInput input = new CustomUploaderInput("", url);
if (uploader.Body == CustomUploaderBody.None)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), null, uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.RequestMethod);
}
else if (uploader.Body == CustomUploaderBody.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.JSON || uploader.Body == CustomUploaderBody.XML)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetData(input), uploader.GetContentType(), null,
uploader.GetHeaders(input));
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
return(result);
}
public override UploadResult ShortenURL(string url)
{
if ((customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$"))) &&
(customUploader.Headers == null || !customUploader.Headers.Any(x => x.Value.Contains("$input$"))))
{
throw new Exception("Atleast one '$input$' required for argument or header value.");
}
UploadResult result = new UploadResult {
URL = url
};
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput("", url);
if (customUploader.RequestType == CustomUploaderRequestMethod.POST)
{
result.Response = SendRequestMultiPart(customUploader.GetRequestURL(), customUploader.GetArguments(input), customUploader.GetHeaders(input), null,
customUploader.ResponseType, customUploader.GetHttpMethod());
}
else
{
result.Response = SendRequest(customUploader.GetHttpMethod(), customUploader.GetRequestURL(), customUploader.GetArguments(input),
customUploader.GetHeaders(input), null, customUploader.ResponseType);
}
try
{
customUploader.ParseResponse(result, true);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult ShortenURL(string url)
{
UploadResult result = new UploadResult {
URL = url
};
CustomUploaderInput input = new CustomUploaderInput("", url);
if (uploader.Body == CustomUploaderBody.None)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), null, uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input), null,
uploader.ResponseType, uploader.RequestMethod);
}
else if (uploader.Body == CustomUploaderBody.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (uploader.Body == CustomUploaderBody.JSON || uploader.Body == CustomUploaderBody.XML)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetData(input), uploader.GetContentType(),
null, uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
try
{
uploader.ParseResponse(result, input, true);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult ShareURL(string url)
{
if ((customUploader.Arguments == null || !customUploader.Arguments.Any(x => x.Value.Contains("$input$"))) &&
(customUploader.Headers == null || !customUploader.Headers.Any(x => x.Value.Contains("$input$"))))
{
throw new Exception("At least one \"$input$\" required for argument or header value.");
}
UploadResult result = new UploadResult {
URL = url, IsURLExpected = false
};
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput("", url);
if (customUploader.RequestType == CustomUploaderRequestMethod.POST)
{
result.Response = SendRequestMultiPart(customUploader.GetRequestURL(), customUploader.GetArguments(input), customUploader.GetHeaders(input), null,
customUploader.ResponseType, customUploader.GetHttpMethod());
}
else
{
result.Response = SendRequest(customUploader.GetHttpMethod(), customUploader.GetRequestURL(), customUploader.GetArguments(input),
customUploader.GetHeaders(input), null, customUploader.ResponseType);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (customUploader.RequestType != CustomUploaderRequestType.POST)
{
throw new Exception("'Request type' must be 'POST' when using custom image uploader.");
}
UploadResult result = UploadData(stream, customUploader.GetRequestURL(), fileName, customUploader.GetFileFormName(), customUploader.GetArguments(), responseType: customUploader.ResponseType);
if (result.IsSuccess)
{
customUploader.ParseResponse(result);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, "");
if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.RequestMethod);
}
else if (uploader.Body == CustomUploaderBody.Binary)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), stream, RequestHelpers.GetMimeType(fileName), null,
uploader.GetHeaders(input));
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
uploader.TryParseResponse(result, LastResponseInfo, input);
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (customUploader.RequestType != CustomUploaderRequestType.POST)
{
throw new Exception("'Request type' must be 'POST' when using custom image uploader.");
}
UploadResult result = UploadData(stream, customUploader.GetRequestURL(), fileName, customUploader.GetFileFormName(), customUploader.GetArguments(),
customUploader.GetHeaders(), responseType: customUploader.ResponseType);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
// TODO: Translate
Errors.Add("Response parse failed." + Environment.NewLine + e);
}
}
return(result);
}
