private async void MenuItemImgur_OnClick(object sender, RoutedEventArgs e)
{
MenuImgur.IsEnabled = false;
var win = new UploadingWindow
{
Owner = this,
WindowStartupLocation = WindowStartupLocation.CenterOwner
};
win.Show();
var url = await Imgur.UploadImage(RenderImage());
win.Close();
if (string.IsNullOrWhiteSpace(url))
{
MessageBox.Show(this, "Upload failed. The upload-ratelimits have been hit, or something went wrong.", "Upload Failed");
}
else
{
Process.Start(new ProcessStartInfo(url));
}
MenuImgur.IsEnabled = true;
}
public async Task Refresh()
{
var rates = await Imgur.GetUploadRatelimits();
IpLimit = rates.Item1;
ClientWideLimit = rates.Item2;
}
private void SortImages(Advertisement ad, List <string> added, List <string> deleted)
{
List <RadioButtonList> radios = Images.GetAll <RadioButtonList>();
List <FileUpload> fileUploads = Images.GetAll <FileUpload>();
for (int i = 0; i < Constants.ImagesPerListing; i++)
{
try
{
if (radios[i].SelectedIndex == UploadNew)
{
byte[] data = GetImage(fileUploads[i]);
if (data == null || data.Length <= 0)
{
continue;
}
string url = Imgur.GetUrl(data);
if (string.IsNullOrEmpty(url))
{
continue;
}
deleted.Add(ad.Images[i]);
added.Add(url);
}
else if (radios[i].SelectedIndex == NoPicture)
{
deleted.Add(ad.Images[i]);
}
} catch { }
}
}
public void ImgurAuthComplete()
{
try
{
string verification = txtImgurVerificationCode.Text;
if (!string.IsNullOrEmpty(verification) && Config.ImgurOAuthInfo != null &&
!string.IsNullOrEmpty(Config.ImgurOAuthInfo.AuthToken) && !string.IsNullOrEmpty(Config.ImgurOAuthInfo.AuthSecret))
{
bool result = new Imgur(Config.ImgurOAuthInfo).GetAccessToken(verification);
if (result)
{
lblImgurAccountStatus.Text = "Login successful: " + Config.ImgurOAuthInfo.UserToken;
MessageBox.Show("Login successful.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
lblImgurAccountStatus.Text = "Login failed.";
MessageBox.Show("Login failed.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
atcImgurAccountType.SelectedAccountType = AccountType.Anonymous;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void imageUpload_DoWork(object sender, DoWorkEventArgs e)
{
try
{
string filePath = Path.GetTempFileName();
Dispatcher.Invoke(new Action(delegate
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create((BitmapSource)imageScreenshot.Source));
using (var stream = new FileStream(filePath, FileMode.Create))
encoder.Save(stream);
}));
string newImageId = Imgur.UploadToImgur(File.ReadAllBytes(filePath));
if (newImageId == null)
{
new Exception("Failed to Upload.");
}
Dispatcher.Invoke(new Action(delegate { _imageID = newImageId; }));
}
catch
{
Dispatcher.Invoke(new Action(
() =>
MetroMessageBox.Show("Error", "Unable to upload Image to server. Try again later.")));
}
}
private async void LoginButton_Click(object sender, RoutedEventArgs e)
{
await Imgur.Authorize(PinCodeInput.Text, settings);
DialogResult = true;
Close();
}
public async Task <bool> IsValid()
{
if (!(DataContext is ImgurPreset preset))
{
return(false);
}
if (string.IsNullOrWhiteSpace(preset.Title))
{
StatusBand.Warning(LocalizationHelper.Get("S.Options.Upload.Preset.Warning.Title"));
return(false);
}
if (UserSettings.All.UploadPresets.OfType <UploadPreset>().Any(a => a.Title != _originalTitle && a.Title == preset.Title.Trim()))
{
StatusBand.Warning(LocalizationHelper.Get("S.Options.Upload.Preset.Warning.Repeated"));
return(false);
}
if (!preset.IsAnonymous && !await Imgur.IsAuthorized(preset))
{
StatusBand.Warning(LocalizationHelper.Get("S.Options.Upload.Preset.Warning.Authenticate"));
return(false);
}
return(true);
}
public void TestCleanup()
{
if (imgur != null)
{
imgur.Dispose();
imgur = null;
}
}
public void RemoveTraceListener(string Name)
{
Bootstrap.RemoveListener(Name);
Application.RemoveListener(Name);
Imgur.RemoveListener(Name);
ImgurBandwidth.RemoveListener(Name);
Discord.RemoveListener(Name);
DiscordLibrary.RemoveListener(Name);
}
public static async Task <string> Upload(BitmapSource bmpSource)
{
using (var ms = new MemoryStream())
{
var tmpFile = new FileInfo(Path.Combine(Config.Instance.DataDir, $"tmp{DateTime.Now.ToFileTime()}.png"));
SaveToStream(ms, bmpSource);
return(await Imgur.Upload(Config.Instance.ImgurClientId, ms, tmpFile.FullName));
}
}
public static async Task <ValidatedEventArgs> IsValid(ImgurPreset preset)
{
if (!preset.IsAnonymous && !await Imgur.IsAuthorized(preset))
{
return(new ValidatedEventArgs("S.SaveAs.Warning.Upload.NotAuthorized", StatusReasons.UploadServiceUnauthorized, () => App.MainViewModel.OpenOptions.Execute(Options.UploadIndex)));
}
return(await preset.IsValid());
}
public static void Initialize(TestContext context)
{
string apiKey = ConfigurationManager
.OpenExeConfiguration(Assembly.GetExecutingAssembly().Location)
.AppSettings
.Settings["Api-Key"].Value;
imgur = new Imgur(apiKey);
}
public async Task SaveOrUploadScreenshot(PngBitmapEncoder pngEncoder, string proposedFileName)
{
if (pngEncoder != null)
{
var saveOperation = await this.ShowScreenshotUploadSelectionDialog();
if (saveOperation.Cancelled)
{
return;
}
var tmpFile = new FileInfo(Path.Combine(Config.Instance.DataDir, $"tmp{DateTime.Now.ToFileTime()}.png"));
var fileName = saveOperation.SaveLocal
? Helper.ShowSaveFileDialog(Helper.RemoveInvalidFileNameChars(proposedFileName), "png") : tmpFile.FullName;
if (fileName != null)
{
string imgurUrl = null;
using (var ms = new MemoryStream())
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
pngEncoder.Save(ms);
ms.WriteTo(fs);
if (saveOperation.Upload)
{
var controller = await this.ShowProgressAsync("Uploading...", "");
imgurUrl = await Imgur.Upload(Config.Instance.ImgurClientId, ms, proposedFileName);
await controller.CloseAsync();
}
}
if (imgurUrl != null)
{
await this.ShowSavedAndUploadedFileMessage(saveOperation.SaveLocal?fileName : null, imgurUrl);
Log.Info("Uploaded screenshot to " + imgurUrl);
}
else
{
await this.ShowSavedFileMessage(fileName);
}
Log.Info("Saved screenshot to: " + fileName);
}
if (tmpFile.Exists)
{
try
{
tmpFile.Delete();
}
catch (Exception ex)
{
Log.Error(ex);
}
}
}
}
private static async Task <string> GetRandomRedditImage(string subreddit)
{
Imgur responseData = new Imgur();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(string.Format("https://api.imgur.com/3/gallery{0}/top/week", subreddit));
request.Headers.Add("Authorization", "Client-ID " + _clientId);
using (Stream response = (await request.GetResponseAsync()).GetResponseStream())
using (StreamReader reader = new StreamReader(response))
responseData = JsonConvert.DeserializeObject <Imgur>(await reader.ReadToEndAsync());
return(responseData.data[_rand.Next(responseData.data.Length)].link);
}
private void btnGrabImageFromXbox_Click(object sender, RoutedEventArgs e)
{
// Show Mask
ImageGrabMask.Visibility = Visibility.Visible;
btnAddImage.IsEnabled = btnGrabImageFromXbox.IsEnabled = false;
var backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += (o, args) =>
{
try
{
// Grab Screenshot from Xbox
string screenshotFileName = Path.GetTempFileName();
string screenshotPng = Path.GetTempFileName();
if (!App.AssemblyStorage.AssemblySettings.Xbdm.GetScreenshot(screenshotFileName))
{
Dispatcher.Invoke(
new Action(
() =>
MetroMessageBox.Show("Not Connected", "You are not connected to a debug Xbox 360, unable to get screenshot")));
return;
}
// do stuff
BitmapSource bitmapSource = DDSConversion.Deswizzle(screenshotFileName, 1204, 720, true, true);
// convert to png
SaveImage(screenshotPng, bitmapSource);
// upload
string response = Imgur.UploadToImgur(File.ReadAllBytes(screenshotPng));
string finalString = string.Format("http://i.imgur.com/{0}.png", response);
Dispatcher.Invoke(new Action(() => _generatorViewModel.Images.Add(new ModPostInfo.Image
{
Url = finalString
})));
}
catch (Exception ex)
{
Dispatcher.Invoke(new Action(() => MetroException.Show(ex)));
}
};
backgroundWorker.RunWorkerCompleted += (o, args) =>
{
ImageGrabMask.Visibility = Visibility.Collapsed;
btnAddImage.IsEnabled = btnGrabImageFromXbox.IsEnabled = true;
};
backgroundWorker.RunWorkerAsync();
}
/// <summary>
/// Adds a logging output destination to all loggers.
/// </summary>
/// <param name="IncludeDiscordLibraryLogger">
/// Whether or not the DiscordLibrary logger should send logging output to the supplied destination;
/// the DiscordLibrary logger should not send its logging output to Discord, as this causes re-entrancy issues
/// </param>
public void AddTraceListener(TraceListener Add, bool IncludeDiscordLibraryLogger)
{
Bootstrap.AddListener(Add);
Application.AddListener(Add);
Imgur.AddListener(Add);
ImgurBandwidth.AddListener(Add);
Discord.AddListener(Add);
if (IncludeDiscordLibraryLogger)
{
DiscordLibrary.AddListener(Add);
}
}
private async void Upload(ImageBuff img)
{
var imgur = new Imgur();
var link = await imgur.UploadAsync(img.ImageSource);
ProcessingIndicator.IsActive = false;
labelProgress.Content = "Uploaded Successful";
tbURL.Text = link;
tbURL.Visibility = Visibility.Visible;
ButtonOk.Visibility = Visibility.Visible;
imageUploaded.Source = new BitmapImage(new Uri(link));
}
private void TokenHyperlink_RequestNavigate(object sender, System.Windows.RoutedEventArgs e)
{
try
{
StatusBand.Hide();
Process.Start(Imgur.GetAuthorizationAdress());
}
catch (Exception ex)
{
LogWriter.Log(ex, "Creating the link and opening a Imgur related page.");
StatusBand.Error(LocalizationHelper.Get("S.Options.Upload.Preset.Warning.GetToken"));
}
}
/// <summary>
/// Upload the image to Imgur as a base64 string
/// </summary>
/// <param name="Base64Image"></param>
public static void Upload(string Base64Image)
{
// Set to false before every upload
hasUploadedSuccessfully = false;
// Send a POST request to Imgur API
Net.Response res = Net.POST("https://api.imgur.com/3/upload.json", new System.Collections.Generic.Dictionary <string, string>
{
{
"image",
Base64Image
}
},
new System.Collections.Generic.Dictionary <string, string>
{
{
"Authorization",
$"Client-ID {Config.conf.ImgurAPI}"
}
});
// Deserialize the result from Imgur
Imgur imgur = Serialization.JSON.Deserialize.getFromJson <Imgur>(res.source);
// Check if Imgur result was successful
if (imgur.success && imgur.status == 200)
{
hasUploadedSuccessfully = true; // Set to true if the image was successfully uploaded
ImgurUrl = $"https://i.imgur.com/{imgur.data.id}.png"; // Set the url with the result data
// Notify the user that the image was uploaded (if enabled)
Utils.Notify("Image Uploaded!", "CaptureThat has uploaded your image to Imgur successfully!", 3);
// Play the Success sound
Utils.PlaySuccess();
// Set the clipboard to the Imgur url
Utils.SetClipboard(GetImgurURL());
// Open the url after the screenshot uploads
Utils.OpenUrlAfterCapture(GetImgurURL());
}
else
{
// Notify the user that the image wasn't uploaded (if enabled)
Utils.Notify("Image Upload Failed!", "CaptureThat has failed to upload your image to Imgur!", 3);
// Play the Error sound
Utils.PlayError();
}
}
public async Task TestGetImage()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(baseUrl + "image/some-image-id")
.Respond(MediaTypeNames.Application.Json,
ResourceRetriever.GetJsonString("responses/get-image-ok.json"));
imgur = new Imgur(apiKey, mockHttp);
Image image = await imgur.GetImage("some-image-id");
Assert.AreEqual("some-image-id", image.Id);
}
public async Task TestDeleteImage()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, baseUrl + "image/some-delete-hash")
.Respond(HttpStatusCode.OK, MediaTypeNames.Application.Json,
ResourceRetriever.GetJsonString("responses/delete-image-ok.json"));
imgur = new Imgur(apiKey, mockHttp);
bool success = await imgur.DeleteImageAnonymous("some-delete-hash");
Assert.IsTrue(success);
}
public async Task <IEnumerable <Tuple <string, string> > > GetImagesFromUrl(string title, string url)
{
try
{
var uri = new Uri(url);
string filename = Path.GetFileName(uri.LocalPath);
//if (filename.EndsWith(".gif"))
// return Enumerable.Empty<Tuple<string, string>>();
if (filename.EndsWith(".jpg") || filename.EndsWith(".png") || filename.EndsWith(".jpeg") || filename.EndsWith(".gif"))
{
return new Tuple <string, string>[] { Tuple.Create(title, url) }
}
;
else
{
var targetHost = uri.DnsSafeHost.ToLower(); //make sure we can compare caseless
switch (targetHost)
{
case "imgur.com":
return(await Imgur.GetImagesFromUri(title, uri));
case "min.us":
return(await Minus.GetImagesFromUri(title, uri));
case "www.quickmeme.com":
case "i.qkme.me":
case "quickmeme.com":
case "qkme.me":
return(Quickmeme.GetImagesFromUri(title, uri));
case "memecrunch.com":
return(Memecrunch.GetImagesFromUri(title, uri));
case "flickr.com":
return(await Flickr.GetImagesFromUri(title, uri));
default:
return(Enumerable.Empty <Tuple <string, string> >());
}
}
}
catch
{
return(Enumerable.Empty <Tuple <string, string> >());
}
}
static ImageAcquisition()
{
var quickmeme = new Quickmeme();
var picsarus = new Picsarus();
var memecrunch = new Memecrunch();
var livememe = new Livememe();
var memedad = new Memedad();
var memegen = new Memegen();
var memefive = new Memefive();
var ehost = new Ehost();
var makeameme = new Makeameme();
var imgflip = new Imgflip();
var crtlv = new Ctrlv();
var picshd = new Picshd();
var redditUploads = new RedditUploads();
_simpleAPIs.Add("qkme.me", quickmeme);
_simpleAPIs.Add("quickmeme.com", quickmeme);
_simpleAPIs.Add("picsarus.com", picsarus);
_simpleAPIs.Add("memecrunch.com", memecrunch);
_simpleAPIs.Add("livememe.com", livememe);
_simpleAPIs.Add("memedad.com", memedad);
_simpleAPIs.Add("memefive.com", memefive);
_simpleAPIs.Add("eho.st", ehost);
_simpleAPIs.Add("makeameme.org", makeameme);
_simpleAPIs.Add("imgflip.com", imgflip);
_simpleAPIs.Add("ctrlv.in", crtlv);
_simpleAPIs.Add("i.reddituploads.com", redditUploads);
_simpleAPIs.Add("reddituploads.com", redditUploads);
_simpleAPIs.Add("picshd.com", picshd);
_simpleAPIs.Add("memegen.com", memegen);
_simpleAPIs.Add("memegen.de", memegen);
_simpleAPIs.Add("memegen.nl", memegen);
_simpleAPIs.Add("memegen.fr", memegen);
_simpleAPIs.Add("memegen.it", memegen);
_simpleAPIs.Add("memegen.es", memegen);
_simpleAPIs.Add("memegen.se", memegen);
_simpleAPIs.Add("memegen.pl", memegen);
var imgur = new Imgur();
var flickr = new Flickr();
var minus = new Minus();
_asyncAPIs.Add("imgur.com", imgur);
_asyncAPIs.Add("flickr.com", flickr);
_asyncAPIs.Add("min.us", minus);
}
public async Task <string> SaveImage(MemoryStream request)
{
Imgur imgur = new Imgur("07504008b27c23f");
try
{
var image = await imgur.UploadImageAnonymous(request, "name", "title", "description");
}
catch (Exception ex)
{
throw;
}
return(null);
}
public async Task TestCreateAlbum()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, baseUrl + "album")
.Respond(HttpStatusCode.OK, MediaTypeNames.Application.Json,
ResourceRetriever.GetJsonString("responses/create-album-ok.json"));
imgur = new Imgur(apiKey, mockHttp);
CreateAlbum album = await imgur.CreateAlbumAnonymous(new string[] { "delete-hash-1" }, "title", "description", AlbumPrivacy.None, AlbumLayout.Blog, "image-id");
Assert.AreEqual("some-delete-hash", album.DeleteHash);
Assert.AreEqual("some-id", album.Id);
}
private async void UpdateAlbumList(bool offline = false)
{
try
{
ThisPanel.IsEnabled = false;
if (!(DataContext is ImgurPreset preset))
{
return;
}
if (!offline && !await Imgur.IsAuthorized(preset))
{
return;
}
var list = offline && preset.Albums != null?preset.Albums.Cast <ImgurAlbum>().ToList() : offline ? null : await Imgur.GetAlbums(preset);
if (list == null)
{
list = new List <ImgurAlbum>();
if (!offline)
{
StatusBand.Error(LocalizationHelper.Get("S.Options.Upload.Preset.Warning.AlbumLoad"));
}
}
if (!offline || list.All(a => a.Id != "♥♦♣♠"))
{
list.Insert(0, new ImgurAlbum {
Id = "♥♦♣♠", Title = LocalizationHelper.Get("S.Options.Upload.Preset.Imgur.AskMe")
});
}
AlbumComboBox.ItemsSource = list;
if (AlbumComboBox.SelectedIndex == -1)
{
AlbumComboBox.SelectedIndex = 0;
}
}
finally
{
ThisPanel.IsEnabled = true;
}
}
public void Capture()
{
main.gameObject.SetActive(false);
StartCoroutine(CaptureScreenAndUpload());
IEnumerator CaptureScreenAndUpload()
{
var path = $"{Application.dataPath}/Screenshots";
var fileName = $"screenshot-{DateTime.Now:MM-dd-HH-mm-ss-fffffff}";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = $@"{path}/{fileName}.png";
ScreenCapture.CaptureScreenshot(path);
yield return(new WaitForSeconds(.5f));
main.gameObject.SetActive(true);
loading.gameObject.SetActive(true);
var fileStream = File.OpenRead(path);
var imageData = new byte[fileStream.Length];
fileStream.Read(imageData, 0, imageData.Length);
fileStream.Close();
var texture = new Texture2D(64, 64, TextureFormat.ARGB32, false);
texture.LoadImage(imageData);
texture.name = Path.GetFileNameWithoutExtension(path);
photo.texture = texture;
Imgur.Upload(path)
.Then(res =>
{
var tex = qrGen.GenerateBarcode(res.data.link, BarcodeFormat.QR_CODE);
qrCode.texture = tex;
qrCode.rectTransform.sizeDelta = new Vector2(tex.width, tex.height);
result.gameObject.SetActive(true);
loading.gameObject.SetActive(false);
})
.Catch(err => Debug.Log(err.Message));
}
}
private IEnumerator Start()
{
var path = $"{Application.dataPath}/Screenshots";
var fileName = "123";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = $@"{path}/{fileName}.png";
ScreenCapture.CaptureScreenshot(path);
yield return(new WaitForSeconds(.5f));
Imgur.Upload(path);
}
public async Task TestUploadImageStream()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, baseUrl + "upload")
.Respond(HttpStatusCode.OK, MediaTypeNames.Application.Json,
ResourceRetriever.GetJsonString("responses/upload-image-stream-ok.json"));
imgur = new Imgur(apiKey, mockHttp);
Image image = await imgur.UploadImageAnonymous(ResourceRetriever.GetStream("images/vs-icon.png"), "name", "title", "description");
Assert.AreEqual("some-id", image.Id);
Assert.AreEqual("title", image.Title);
Assert.AreEqual("some-delete-hash", image.Deletehash);
Assert.AreEqual("https://i.imgur.com/some-id.png", image.Link);
Assert.AreEqual("image/png", image.Type);
}
public void ImgurAuthOpen()
{
try
{
OAuthInfo oauth = new OAuthInfo(APIKeys.ImgurConsumerKey, APIKeys.ImgurConsumerSecret);
string url = new Imgur(oauth).GetAuthorizationURL();
if (!string.IsNullOrEmpty(url))
{
Config.ImgurOAuthInfo = oauth;
ZAppHelper.LoadBrowserAsync(url);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private List <string> GetImages()
{
List <string> images = new List <string>();
for (int index = 0; index < Request.Files.Count; index++)
{
HttpPostedFile file = Request.Files[index];
string extension = Path.GetExtension(file.FileName);
try
{
if (string.IsNullOrEmpty(extension))
{
continue;
}
Stream stream = file.InputStream;
if (stream.Length == 0 || stream.Length > 2 << 22)
{
continue;
}
byte[] data = new BinaryReader(stream).ReadBytes((int)stream.Length);
string url = Imgur.GetUrl(data);
if (string.IsNullOrEmpty(url))
{
continue;
}
images.Add(url);
}
catch (Exception)
{
// ignored
}
}
return(images);
}
/// <summary>
///
/// </summary>
/// <param name="imgur"></param>
public MemeGenEndpoint(Imgur imgur)
{
ImgurClient = imgur;
}
/// <summary>
///
/// </summary>
/// <param name="imgurClient"></param>
public ConversationEndpoint(Imgur imgurClient)
{
ImgurClient = imgurClient;
}
/// <summary>
///
/// </summary>
/// <param name="imgur"></param>
public AccountEndpoint(Imgur imgur)
{
ImgurClient = imgur;
}
/// <summary>
///
/// </summary>
/// <param name="imgur"></param>
public NotifcationEndpoint(Imgur imgur)
{
ImgurClient = imgur;
}
/// <summary>
///
/// </summary>
/// <param name="imgur"></param>
public ImageEndpoint(Imgur imgur)
{
ImgurClient = imgur;
}
public CommentEndpoint(Imgur imgurClient)
{
ImgurClient = imgurClient;
}
private UploadResult UploadImage(string ssPath)
{
ImageUploader imageUploader = null;
if (!string.IsNullOrEmpty(App.Settings.PtpImgCode))
{
imageUploader = new PtpImageUploader(Crypt.Decrypt(App.Settings.PtpImgCode));
}
else
{
switch (App.Settings.ProfileActive.ImageUploaderType)
{
case ImageDestination.Imgur:
if (App.UploadersConfig.ImgurOAuth2Info == null)
{
App.UploadersConfig.ImgurOAuth2Info = new OAuth2Info(APIKeys.ImgurClientID, APIKeys.ImgurClientSecret);
}
string albumID = null;
if (App.UploadersConfig.ImgurUploadSelectedAlbum && App.UploadersConfig.ImgurSelectedAlbum != null)
{
albumID = App.UploadersConfig.ImgurSelectedAlbum.id;
}
imageUploader = new Imgur(App.UploadersConfig.ImgurOAuth2Info)
{
UploadMethod = App.UploadersConfig.ImgurAccountType,
DirectLink = App.UploadersConfig.ImgurDirectLink,
ThumbnailType = App.UploadersConfig.ImgurThumbnailType,
UploadAlbumID = albumID
};
break;
case ImageDestination.TinyPic:
imageUploader = new TinyPicUploader(APIKeys.TinyPicID, APIKeys.TinyPicKey, App.UploadersConfig.TinyPicAccountType, App.UploadersConfig.TinyPicRegistrationCode);
break;
case ImageDestination.Flickr:
imageUploader = new FlickrUploader(APIKeys.FlickrKey, APIKeys.FlickrSecret, App.UploadersConfig.FlickrAuthInfo, App.UploadersConfig.FlickrSettings);
break;
case ImageDestination.Photobucket:
imageUploader = new Photobucket(App.UploadersConfig.PhotobucketOAuthInfo, App.UploadersConfig.PhotobucketAccountInfo);
break;
case ImageDestination.Picasa:
imageUploader = new Picasa(App.UploadersConfig.PicasaOAuth2Info)
{
AlbumID = App.UploadersConfig.PicasaAlbumID
};
break;
case ImageDestination.Twitter:
OAuthInfo twitterOAuth = App.UploadersConfig.TwitterOAuthInfoList.ReturnIfValidIndex(App.UploadersConfig.TwitterSelectedAccount);
imageUploader = new Twitter(twitterOAuth);
break;
case ImageDestination.Chevereto:
imageUploader = new Chevereto(App.UploadersConfig.CheveretoWebsite, App.UploadersConfig.CheveretoAPIKey)
{
DirectURL = App.UploadersConfig.CheveretoDirectURL
};
break;
case ImageDestination.HizliResim:
imageUploader = new HizliResim()
{
DirectURL = true
};
break;
case ImageDestination.CustomImageUploader:
if (App.UploadersConfig.CustomUploadersList.IsValidIndex(App.UploadersConfig.CustomImageUploaderSelected))
{
imageUploader = new CustomImageUploader(App.UploadersConfig.CustomUploadersList[App.UploadersConfig.CustomImageUploaderSelected]);
}
break;
case ImageDestination.FileUploader:
return UploadFile(ssPath);
}
}
if (imageUploader != null)
{
PrepareUploader(imageUploader);
return imageUploader.Upload(ssPath);
}
return null;
}
/// <summary>
///
/// </summary>
/// <param name="imgur"></param>
public AlbumEndpoint(Imgur imgur)
{
ImgurClient = imgur;
}
