public async void RemoveNonsupportedImages_removes_correct_things()
{
var mock = new Mock <ISettingsManager>();
mock.Setup(m => m.GetSupportedExtensions()).Returns(new StringCollection {
".jpg"
});
var album = new ImgurAlbum
{
Images =
new List <ImgurImage>
{
new ImgurImage {
Type = "image/jpg"
},
new ImgurImage {
Type = "image/png"
},
new ImgurImage {
Type = "image/gif"
}
}
};
album.Settings = mock.Object;
await album.RemoveNonsupportedImages();
Assert.Equal(1, album.Images.Count);
Assert.Equal("image/jpg", album.Images.First().Type);
}
public void AlbumCRUD()
{
string albumTitle = "K1tt3ns!";
string descriptor = "An album created to talk about cats";
string albumTitleUpdate = "dogsarecool";
string albumDescUpdate = "album desc update";
// grab some images (from another album) to use in our test album
List <ImgurImage> listOfImages = new List <ImgurImage>(ImgurApiSource.Instance.AlbumImagesAsync(testAlbum).Result);
// create the album
ImgurAlbum album = ImgurApiSource.Instance.AlbumCreationAsync(listOfImages, listOfImages[0], albumTitle, descriptor, Privacy.ignore, Layout.ignore).Result;
Assert.AreEqual(album.Title, albumTitle);
Assert.AreEqual(album.Description, descriptor);
Assert.AreEqual(album.ImagesInAlbum, listOfImages.Count);
// update information
List <string> stringList = new List <string>();
ImgurBasic responseBasic = ImgurApiSource.Instance.AlbumUpdateAsync(album.deletehash, stringList, null, albumTitleUpdate, albumDescUpdate, Privacy.hidden, Layout.blog).Result;
Assert.IsTrue(responseBasic.success);
// destroy
ImgurBasic deleteResponse = ImgurApiSource.Instance.AlbumDeletionAsync(album.deletehash).Result;
Assert.IsTrue(deleteResponse.success);
}
public async void GetContent_given_albumid_with_images_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 albumId = "example";
var imageNum = 15;
var album = new ImgurAlbum {
Images = new List <ImgurImage>(Enumerable.Repeat(new ImgurImage {
Type = "image/test"
}, imageNum))
};
var handler = StubHttpClient.GetHandler();
handler.AddResponse(new Uri($"https://api.imgur.com/3/album/{albumId}"), HttpStatusCode.OK, new ApiHelper <ImgurAlbum> {
Data = album
});
var source = new ImgurAlbumSource(StubHttpClient.Create(handler), mock.Object);
var result = await source.GetContent(albumId);
Assert.NotNull(result);
Assert.NotNull(result.Images);
Assert.Equal(0, result.Images.Count);
mock.Verify(i => i.LimitsHaveBeenLoaded(), Times.Once);
mock.Verify(i => i.IsRequestAllowed(), Times.Once);
}
public void GetAlbumDetailsTest()
{
ImgurAlbum album = ImgurApiSource.Instance.AlbumDetailsAsync(testAlbum.ToString()).Result;
// TODO: Fill in better test details
Assert.IsNotNull(album);
}
private static void DumpAlbumInfo(ImgurAlbum alb)
{
Console.WriteLine("\nAlbum Info:");
Console.WriteLine(" Link: " + alb.Link);
Console.WriteLine(" Image Count: " + alb.ImagesCount);
Console.WriteLine(" Date Added: " + alb.TimeAdded);
Console.WriteLine(" Views: " + alb.Views);
Console.WriteLine(" Delete Hash: " + alb.DeleteHash);
}
public async Task <ImgurPicture> GetImage(string query)
{
ImgurAlbum album = await ImgurConnection.QuerySearch(query);
if (album == null)
{
return(null);
}
else
{
return(album.data[(new Random()).Next(album.data.Count)]);
}
}
private async Task GetAlbum()
{
ImgurAlbum tmpAlbum = null;
if (File.Exists(_albumSavePath))
{
tmpAlbum = JsonConvert.DeserializeObject <ImgurAlbum>(File.ReadAllText(_albumSavePath));
if (string.IsNullOrEmpty(tmpAlbum.DeleteHash))
{
File.Delete(_albumSavePath);
tmpAlbum = null;
}
else
{
try
{
_ = await _client.GetAlbum(tmpAlbum.Id);
}
catch
{
Debug.WriteLine($"Album does not exist: {tmpAlbum} with id: {tmpAlbum.Id} -> creating new one");
File.Delete(_albumSavePath);
tmpAlbum = null;
}
}
}
else if (Path.GetDirectoryName(_albumSavePath) != null && !Directory.Exists(Path.GetDirectoryName(_albumSavePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(_albumSavePath) ?? throw new InvalidOperationException());
}
if (tmpAlbum == null)
{
tmpAlbum = await _client.CreateAlbum();
Debug.WriteLine($"Created album: {tmpAlbum} with deleteHash: {tmpAlbum.DeleteHash}");
}
if (tmpAlbum != null)
{
_album = tmpAlbum;
File.WriteAllText(_albumSavePath, JsonConvert.SerializeObject(_album));
}
}
/// <summary>
/// Create a new album.
/// </summary>
/// <param name="imageIDs">The image ids that you want to be included in the album.</param>
/// <param name="coverImageId">The id of the image you want to set as the cover. If the coverImageID 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>
/// <returns></returns>
public async Task <ImgurAlbum> AlbumCreationAsync(List <string> imageIDs, string coverImageId, String title = "", String description = "", Privacy albumPrivacy = Privacy.ignore, Layout albumLayout = Layout.ignore)
{
MultipartFormDataContent content = new MultipartFormDataContent(BoundaryGuid.ToString());
if (imageIDs.Count != 0 || imageIDs == null)
{
string serializedImageList = await Task.Run(() => JsonConvert.SerializeObject(imageIDs));
content.Add(new StringContent(serializedImageList), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.ids]);
}
if (imageIDs.Contains(coverImageId))
{
content.Add(new StringContent(coverImageId), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.cover]);
}
if (title != "")
{
content.Add(new StringContent(title), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.title]);
}
if (description != "")
{
content.Add(new StringContent(description), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.description]);
}
if (albumPrivacy != Privacy.ignore)
{
content.Add(new StringContent(Utilities.convertToString(albumPrivacy)), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.privacy]);
}
if (albumLayout != Layout.ignore)
{
content.Add(new StringContent(Utilities.convertToString(albumLayout)), ImgurEndpoints.ImageEndpointParameterLookup[ImgurParameters.layout]);
}
String responseString = await PostAnonymousImgurDataAsync(ImgurEndpoints.AlbumCreation(), content);
ImgurBasicWithAlbum status = await Task.Run(() => JsonConvert.DeserializeObject <ImgurBasicWithAlbum>(responseString, _defaultSerializerSettings));
// By default, we only get the deletehash in the basic response but this should really include the deletehash
// so we make another call to fill in the rest of the details about the object
ImgurAlbum album = await this.AlbumDetailsAsync(status.data.id);
album.deletehash = status.data.deletehash;
return(album);
}
public async void Downloader(string mediaId)
{
album = await imgur.GetAlbum(mediaId);
for (int i = 0; i < album.ImagesCount; i++)
{
using (var client = new WebClient())
{
string filename = Path.GetFileName(new Uri(album.Images[i].Link).AbsolutePath);
if (!allIds.Contains(album.Images[i].Id))
{
Directory.CreateDirectory(@"Imgur\" + mediaId);
allIds.Add(album.Images[i].Id);
client.DownloadFile(album.Images[i].Link, @"Imgur\" + mediaId + @"\" + album.Images[i].Id + ".jpg");
File.WriteAllLines("allIds.txt", allIds);
}
}
}
}
public async void ParseSource_given_album_link_calls_ISource_for_album()
{
var sourceMock = new Mock <ISource <ImgurAlbum> >();
var input = "imgur.com/a/test";
var albumId = "test";
var mockReturn = new ImgurAlbum()
{
Images = new List <ImgurImage> {
new ImgurImage(), new ImgurImage()
}
};
sourceMock.Setup(m => m.GetContent(albumId)).ReturnsAsync(mockReturn);
var handler = new ImgurHandler(sourceMock.Object, null);
var output = await handler.ParseSource(input);
Assert.Equal(2, output.GetImages().ToList().Count);
sourceMock.Verify(i => i.GetContent(albumId), Times.Once);
}
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);
}
}
private static EmbedData GetEmbedData(ImgurAlbum album)
{
var ci = album.Images.FirstOrDefault(im => im.Id == album.Cover) ?? album.Images[0];
var d = GetEmbedData(ci);
d.Url = "https://imgur.com/a/" + album.Id;
d.Title = album.Title ?? d.Title;
d.Description = album.Description ?? d.Description;
if (album.Images.Length > 1)
{
d.Type = EmbedDataTypes.MixedContent;
foreach (var img in album.Images)
{
if (img != ci)
{
d.Medias.Add(img.ToMedia());
}
}
}
return(d);
}
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 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);
}
