private void ExecuteRefreshCommand()
{
ImgurImage value = Posts[1];
Posts[1] = Posts[5];
Posts[5] = value;
}
private void TakeFullScreenSnapsShot()
{
if (!_imgurApi.IsLoggedIn())
{
return;
}
_imgurApi.RefreshToken();
var windowStateBefore = WindowState;
var showInTaskbarBefore = ShowInTaskbar;
if (WindowState == WindowState.Normal)
{
WindowState = WindowState.Minimized;
ShowInTaskbar = false;
while (ShowInTaskbar)
{
}
}
var screenShot = new ScreenShot();
var screenBuffer = screenShot.CaptureScreen();
var imgurUpload = new ImgurImage(screenBuffer);
WindowState = windowStateBefore;
ShowInTaskbar = showInTaskbarBefore;
}
public async void GetContent_given_username_with_1_image_of_invalid_type_returns_empty_album()
{
var mock = new Mock <ImgurRatelimiter>(null);
mock.Setup(m => m.IsRequestAllowed()).Returns(true);
mock.Setup(m => m.LimitsHaveBeenLoaded()).Returns(true);
var username = "******";
var image = new ImgurImage {
Height = 10, Width = 5, Title = "title", Type = "image/png"
};
var handler = StubHttpClient.GetHandler();
handler.AddResponse(new Uri($"https://api.imgur.com/3/account/{username}/images/count"), HttpStatusCode.OK, new ApiHelper <int> {
Data = 1
});
handler.AddResponse(new Uri($"https://api.imgur.com/3/account/{username}/images/0"), HttpStatusCode.OK, new ApiHelper <ICollection <ImgurImage> > {
Data = new List <ImgurImage> {
image
}
});
var source = new ImgurAccountImagesSource(StubHttpClient.Create(handler), mock.Object);
source.Settings = CreateSettings();
var result = await source.GetContent(username);
Assert.NotNull(result);
Assert.Empty(result.Images);
mock.Verify(i => i.LimitsHaveBeenLoaded(), Times.Once);
mock.Verify(i => i.IsRequestAllowed(), Times.Exactly(2));
}
/// <summary>
/// Delete an imgur image, this is done by specifying the delete hash
/// </summary>
/// <param name="imgurImage"></param>
/// <param name="token"></param>
public async Task <string> DeleteImgurImageAsync(ImgurImage imgurImage, CancellationToken token = default)
{
Log.Debug().WriteLine("Deleting Imgur image for {0}", imgurImage.Data.Deletehash);
var deleteUri = new Uri(string.Format(_imgurConfiguration.ApiUrl + "/image/{0}", imgurImage.Data.Deletehash));
string responseString;
Behaviour.MakeCurrent();
using (var client = HttpClientFactory.Create(deleteUri))
{
var response = await client.DeleteAsync(deleteUri, token).ConfigureAwait(false);
if ((response.StatusCode != HttpStatusCode.NotFound) && (response.StatusCode != HttpStatusCode.BadRequest))
{
await response.HandleErrorAsync().ConfigureAwait(false);
}
responseString = await response.GetAsAsync <string>(token).ConfigureAwait(false);
Log.Debug().WriteLine("Delete result: {0}", responseString);
}
// Make sure we remove it from the history, if no error occured
_imgurConfiguration.RuntimeImgurHistory.Remove(imgurImage.Data.Id);
_imgurConfiguration.ImgurUploadHistory.Remove(imgurImage.Data.Id);
// dispose is called inside the imgurInfo object
imgurImage.Image = null;
return(responseString);
}
public async void GetContent_given_valid_url_of_invalid_imageformat_returns_null()
{
var mock = new Mock <ImgurRatelimiter>(null);
mock.Setup(m => m.IsRequestAllowed()).Returns(true);
mock.Setup(m => m.LimitsHaveBeenLoaded()).Returns(true);
var imageId = "example";
var output = new ImgurImage {
Height = 5, Width = 10, Title = "test", Link = $"i.imgur.com/{imageId}", Type = "image/png"
};
var handler = StubHttpClient.GetHandler();
handler.AddResponse(new Uri($"https://api.imgur.com/3/image/{imageId}"), HttpStatusCode.OK, new ApiHelper <ImgurImage> {
Data = output
});
var source = new ImgurImageSource(StubHttpClient.Create(handler), mock.Object);
source.Settings = CreateSettings();
var result = await source.GetContent(imageId);
Assert.Null(result);
mock.Verify(i => i.LimitsHaveBeenLoaded(), Times.Once);
mock.Verify(i => i.IsRequestAllowed(), Times.Once);
}
public PostDetailViewModel(ImgurImage image)
{
PostData = image;
UpvoteCommand = new RelayCommand(Upvote);
DownvoteCommand = new RelayCommand(Downvote);
FavoriteCommand = new RelayCommand(Favorite);
DownloadCommentsCommand = new RelayCommand(DownloadComments, () => !seeAllComments);
}
public async void GetImageType_returns_correct_type()
{
var image = new ImgurImage {
Type = "image/jpg"
};
Assert.Equal(".jpg", await image.GetImageType());
}
public async void GetImageName_returns_correct_name()
{
var image = new ImgurImage {
Link = "example.com/test.jpg", Type = "image/jpg", Title = "hello"
};
Assert.Equal("hello.jpg", await image.GetImageName());
}
private async void button1_Click(object sender, EventArgs e)
{
button1.Enabled = false;
button2.Enabled = false;
var result = await mApi.UploadImage(pictureBox1.Image);
mImgurImage = result;
this.Close();
}
private static void DumpImageInfo(ImgurImage img)
{
Console.WriteLine("\nImage Info:");
Console.WriteLine(" ID: " + img.ID);
Console.WriteLine(" Link: " + img.Link);
Console.WriteLine(" Image Type: " + img.Type);
Console.WriteLine(" Date Added: " + img.TimeAdded);
Console.WriteLine(" Views: " + img.Views);
Console.WriteLine(" Delete Hash: " + img.DeleteHash);
}
public void ImageDetailsFilledInForImage()
{
ImgurGalleryImageList testImageList = ImgurApiSource.Instance.GetMainGalleryImagesAsync(MainGallerySection.hot, MainGallerySort.viral, 0).Result;
ImgurImage testImage = testImageList.Images.ElementAt(3);
ImgurImage newtestImage = ImgurApiSource.Instance.GetImageDetailsAsync(testImage.ID).Result;
Assert.IsNotNull(newtestImage.isAnimated);
Assert.IsNotNull(newtestImage.Height);
Assert.IsNotNull(newtestImage.Bandwidth);
}
public void DeleteUploadedImageByDeleteHash()
{
ImgurImage test = ImgurApiSource.Instance.PostImageAnonymousAsync(ImageBytes, "Hello", "DescriptionTest").Result;
System.Threading.SpinWait.SpinUntil(() => 0 == 1, TimeSpan.FromSeconds(4));
Assert.IsNotNull(test.Deletehash);
ImgurBasic result = ImgurApiSource.Instance.DeleteImageAsync(test.Deletehash).Result;
Assert.IsTrue(result.success);
}
public void UploadImageWithURL()
{
ImgurImage test = ImgurApiSource.Instance.PostImageAnonymousAsync(TestImage, "Hello", "DescriptionTest").Result;
Assert.IsNotNull(test.Deletehash);
// Queue this particular image for deletion
imagesToDelete.Add(test);
test = ImgurApiSource.Instance.GetImageDetailsAsync(test.ID).Result;
Assert.AreEqual("Hello", test.Title);
Assert.AreEqual("DescriptionTest", test.Description);
}
/// <summary>
/// Retrieve the thumbnail of an imgur image
/// </summary>
/// <param name="imgurImage">ImgurImage</param>
/// <param name="token">CancellationToken</param>
public async Task RetrieveImgurThumbnailAsync(ImgurImage imgurImage, CancellationToken token = default)
{
if (imgurImage.Image != null)
{
Log.Debug().WriteLine("Imgur thumbnail already available.");
return;
}
if (imgurImage.Data.LinkThumbnail == null)
{
Log.Debug().WriteLine("Imgur URL was null, not retrieving thumbnail.");
return;
}
Log.Debug().WriteLine("Retrieving Imgur image for {0} with url {1}", imgurImage.Data.Id, imgurImage.Data.LinkThumbnail);
ImageHttpBehaviour.MakeCurrent();
imgurImage.Image = await imgurImage.Data.LinkThumbnail.GetAsAsync <BitmapSource>(token).ConfigureAwait(true);
}
private static EmbedData GetEmbedData(ImgurImage img)
{
var media = img.ToMedia();
return(new EmbedData()
{
Url = media.Location,
Title = img.Title,
Description = img.Description,
Type = img.IsAnimated ? EmbedDataTypes.SingleVideo : EmbedDataTypes.SingleImage,
ProviderName = "Imgur",
ProviderUrl = "https://imgur.com",
RestrictionPolicy = media.RestrictionPolicy,
MetadataImage = media,
Medias = new[] { media }
});
}
public void UpdateImageByDeleteHash()
{
ImgurImage test = ImgurApiSource.Instance.ImageUploadAsync(ImageBytes, "Hello", "DescriptionTest").Result;
// pause for 4 seconds while the server updates
System.Threading.SpinWait.SpinUntil(() => 0 == 1, TimeSpan.FromSeconds(4));
Assert.IsNotNull(test.Deletehash);
ImgurBasic result = ImgurApiSource.Instance.ImageUpdateAsync(test.Deletehash, "NewTitle", "NewDescription").Result;
// pause for 4 more seconds while the server updates
System.Threading.SpinWait.SpinUntil(() => 0 == 1, TimeSpan.FromSeconds(4));
ImgurImage image = ImgurApiSource.Instance.ImageDetailsAsync(test.ID).Result;
Assert.AreEqual(image.Title, "NewTitle");
Assert.AreEqual(image.Description, "NewDescription");
}
private static async void UploadImage()
{
try
{
//Image
ImgurImage urlImage = await imgur.UploadImageAnonymous("https://assets-cdn.github.com/images/modules/logos_page/GitHub-Mark.png", "name", "title", "description");
byte[] buff = File.ReadAllBytes("vs-icon.png");
MemoryStream ms = new MemoryStream(buff);
ImgurImage streamImage = await imgur.UploadImageAnonymous(ms, "name", "title", "description");
bool updated = await imgur.UpdateImageAnonymous(streamImage.Deletehash, "updated title", "a new description");
ImgurImage getImage = await imgur.GetImage(streamImage.Id);
//Album
ImgurCreateAlbum createdAlbum = await imgur.CreateAlbumAnonymous(new string[] { streamImage.Id }, "album title", "album description", ImgurAlbumPrivacy.Public, ImgurAlbumLayout.Horizontal, streamImage.Id);
bool result = await imgur.UpdateAlbumAnonymous(createdAlbum.DeleteHash, new string[] { streamImage.Id, urlImage.Id }, "updated album title", "update album description", ImgurAlbumPrivacy.Hidden, ImgurAlbumLayout.Blog, urlImage.Id);
bool addImagesResult = await imgur.AddImagesToAlbumAnonymous(createdAlbum.DeleteHash, new string[] { streamImage.Id, urlImage.Id });
bool removeImagesResult = await imgur.RemoveImagesFromAlbumAnonymous(createdAlbum.DeleteHash, new string[] { urlImage.Id });
ImgurAlbum album = await imgur.GetAlbum(createdAlbum.Id);
//Delete
bool deleteAlbum = await imgur.DeleteAlbumAnonymous(createdAlbum.DeleteHash);
bool deletedUrlImage = await imgur.DeleteImageAnonymous(urlImage.Deletehash);
bool deletedStreamImage = await imgur.DeleteImageAnonymous(streamImage.Deletehash);
}
catch (Exception e)
{
System.Console.Write(e.Message);
}
}
/// <summary>
/// Retrieve the thumbnail of an imgur image
/// </summary>
/// <param name="imgurImage">ImgurImage</param>
/// <param name="token">CancellationToken</param>
public static async Task RetrieveImgurThumbnailAsync(ImgurImage imgurImage, CancellationToken token = default)
{
if (imgurImage.Image != null)
{
Log.Info().WriteLine("Imgur thumbnail already available.");
return;
}
if (imgurImage.Data.LinkThumbnail == null)
{
Log.Info().WriteLine("Imgur URL was null, not retrieving thumbnail.");
return;
}
Log.Info().WriteLine("Retrieving Imgur image for {0} with url {1}", imgurImage.Data.Id, imgurImage.Data.LinkThumbnail);
Behaviour.MakeCurrent();
using (var client = HttpClientFactory.Create(imgurImage.Data.LinkThumbnail))
{
using (var response = await client.GetAsync(imgurImage.Data.LinkThumbnail, token).ConfigureAwait(false))
{
await response.HandleErrorAsync().ConfigureAwait(false);
imgurImage.Image = await response.GetAsAsync <BitmapSource>(token).ConfigureAwait(false);
}
}
}
private static async void UploadImage()
{
try
{
API.CreateSession();
//bool Check = await API.ChechToken("");
//System.Console.WriteLine(Check);
string Code = API.RequestPin();
if (Code.Contains(".com"))
{
Console.WriteLine(Code);
Console.Write("Write Pin: ");
Code = Console.ReadLine();
}
ImgurToken Token = await API.RequestTokenWithPin(Code);
System.Console.WriteLine(Token.Access_token);
ImgurToken ResetToken = await API.ResetToken(Token);
Token = ResetToken;
System.Console.WriteLine(ResetToken.Access_token);
await API.GetImagesAlbum("Chww0");
long ImageCount = await API.GetImageCount(Token);
System.Console.WriteLine(ImageCount);
ImgurAccount Account = await API.GetAccount("letuananh035");
System.Console.WriteLine(Account.Id);
System.Console.WriteLine(Account.Description);
System.Console.WriteLine(Account.URL);
List <ImgurImage> Images = await API.GetImages(Token);
System.Console.WriteLine(Images[0].Link);
ImgurImage urlImage = await API.UploadImage("https://assets-cdn.github.com/images/modules/logos_page/GitHub-Mark.png", "title", "description", Token);
System.Console.Write(urlImage.Link);
byte[] buff = File.ReadAllBytes("vs-icon.png");
MemoryStream ms = new MemoryStream(buff);
ImgurImage streamImage = await API.UploadImage(ms, "title", "description", Token);
bool updated = await API.UpdateImage(streamImage.Id, "updated title", "a new description", Token);
ImgurImage getImage = await API.GetImage(streamImage.Id);
System.Console.Write(getImage.Link);
//Album
ImgurCreateAlbum createdAlbum = await API.CreateAlbum(new string[] { streamImage.Id }, "album title", "album description", ImgurAlbumPrivacy.Public, ImgurAlbumLayout.Horizontal, streamImage.Id, Token);
bool result = await API.UpdateAlbum(createdAlbum.Id, new string[] { streamImage.Id, urlImage.Id }, "updated album title", "update album description", ImgurAlbumPrivacy.Hidden, ImgurAlbumLayout.Blog, urlImage.Id, Token);
bool addImagesResult = await API.AddImagesToAlbum(createdAlbum.DeleteHash, new string[] { streamImage.Id, urlImage.Id }, Token);
ImgurAlbum album = await API.GetAlbum(createdAlbum.Id);
bool removeImagesResult = await API.RemoveImagesFromAlbum(createdAlbum.DeleteHash, new string[] { urlImage.Id }, Token);
//Delete
bool deleteAlbum = await API.DeleteAlbum(createdAlbum.Id, Token);
bool deletedUrlImage = await API.DeleteImage(urlImage.Deletehash);
bool deletedStreamImage = await API.DeleteImage(streamImage.Id, Token);
}
catch (Exception e)
{
System.Console.Write(e.Message);
}
}
public void AddImgurImage(ImgurImage imgurImage)
{
mImgurImageList.Add(imgurImage);
}
public static IMGURDec GetImages(string contextURL)
{
IMGURDec _dec = new IMGURDec();
_dec.ContextURL = contextURL;
string[] _ext = Tools.GetFileExtension(contextURL);
ImgurDotNet.Imgur _gurl = new Imgur();
bool _isImage = false;
try { ImgurImage _img = _gurl.GetImage(_ext[0]); _isImage = true; }
catch (Exception ex) { }
if (!_ext[1].Equals("=(") || _isImage)
{
if (_isImage)
{
//is image
ImgurImage _img = _gurl.GetImage(_ext[0]);
_dec.FullURLs = new string[] { _img.OriginalUrl.ToString() };
_dec.IsAlbum = false;
_dec.Titles = new string[] { _img.Title };
_dec.Descs = new string[] { _img.Name };
if (!_ext[1].Equals("=("))
{
_dec.FileTypes = new string[] { _ext[1] };
_dec.FileNames = new string[] { _ext[0] + "." + _ext[1] };
if (!_ext[1].Equals("gif") && !_ext[1].Equals("gifv"))
{
string[] _mime = _img.Type.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (!_mime[_mime.Length - 1].Equals(_dec.FileTypes))
{
_dec.FileTypes = new string[] { _mime[_mime.Length - 1] };
}
}
}
else
{
string[] _ext0 = Tools.GetFileExtension(_img.OriginalUrl.ToString());
_dec.FileTypes = new string[] { _ext0[1] };
_dec.FileNames = new string[] { _ext0[0] + "." + _ext0[1] };
}
}
else
{
_dec.FullURLs = new string[] { contextURL };
_dec.IsAlbum = false;
_dec.Titles = new string[] { "NOTITLE" };
_dec.FileTypes = new string[] { _ext[1] };
_dec.FileNames = new string[] { _ext[0] + "." + _ext[1] };
_dec.Descs = new string[] { "NODESC" };
}
}
else
{
ImgurAlbum _alb = _gurl.GetAlbum(_ext[0]);
string[] _fullURLS = new string[_alb.Images.Count];
string[] _titles = new string[_alb.Images.Count];
string[] _descs = new string[_alb.Images.Count];
string[] _fileTypes = new string[_alb.Images.Count];
string[] _fileNames = new string[_alb.Images.Count];
int _count = 0;
foreach (ImgurImage _img in _alb.Images)
{
string[] _ext2 = Tools.GetFileExtension(_img.OriginalUrl.ToString());
_fullURLS[_count] = _img.OriginalUrl.ToString();
_titles[_count] = _img.Title;
_descs[_count] = _img.Caption;
_fileTypes[_count] = _ext2[1];
_fileNames[_count] = _ext2[0] + "." + _ext2[1];
if (!_ext[1].Equals("gif") && !_ext2[1].Equals("gifv"))
{
string[] _mime = _img.Type.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (!_mime[_mime.Length - 1].Equals(_fileTypes[_count]))
{
_fileTypes[_count] = _mime[_mime.Length - 1];
}
}
_count++;
}
_dec.IsAlbum = true;
_dec.FullURLs = _fullURLS;
_dec.Titles = _titles;
_dec.Descs = _descs;
_dec.FileTypes = _fileTypes;
_dec.FileNames = _fileNames;
}
return(_dec);
}
/// <summary>
/// Create a new album.
/// </summary>
/// <param name="imageList">The images that you want to be included in the album.</param>
/// <param name="coverImage">The image you want to set as the cover. If the coverImage isn't in the list you specified in the first parameter, this is ignored.</param>
/// <param name="title"> The title of the album </param>
/// <param name="description">The description of the album</param>
/// <param name="albumPrivacy">Sets the privacy level of the album. Values are : public | hidden | secret. Defaults to user's privacy settings for logged in users.</param>
/// <param name="albumLayout">Sets the layout to display the album. Values are : blog | grid | horizontal | vertical</param>
public async Task <ImgurAlbum> AlbumCreationAsync(List <ImgurImage> imageList, ImgurImage coverImage, String title = "", String description = "", Privacy albumPrivacy = Privacy.ignore, Layout albumLayout = Layout.ignore)
{
List <string> imageIDList = new List <string>();
foreach (ImgurImage i in imageList)
{
imageIDList.Add(i.ID);
}
return(await AlbumCreationAsync(imageIDList, coverImage.ID, title, description, albumPrivacy, albumLayout));
}
/// <summary>
/// Update the information of an album. For anonymous albums, {album} should be the deletehash that is returned at creation.
/// </summary>
/// <param name="albumID">The album ID to update</param>
/// <param name="imageList">The images that you want to be included in the album.</param>
/// <param name="coverImage">The image you want to set as the cover.</param>
/// <param name="title"> The title of the album </param>
/// <param name="description">The description of the album</param>
/// <param name="albumPrivacy">Sets the privacy level of the album. Values are : public | hidden | secret. Defaults to user's privacy settings for logged in users.</param>
/// <param name="albumLayout">Sets the layout to display the album. Values are : blog | grid | horizontal | vertical</param>
/// <returns></returns>
public async Task <ImgurBasic> AlbumUpdateAsync(string albumID, List <ImgurImage> imageList, ImgurImage coverImage, String title = "", String description = "", Privacy albumPrivacy = Privacy.ignore, Layout albumLayout = Layout.ignore)
{
List <string> imageIDList = new List <string>();
if (imageList != null)
{
foreach (ImgurImage i in imageList)
{
imageIDList.Add(i.ID);
}
}
return(await AlbumUpdateAsync(albumID, imageIDList, coverImage.ID, title, description, albumPrivacy, albumLayout));
}
