/// <summary>
/// Get promotable media feeds
/// </summary>
public async Task <IResult <InstaMediaList> > GetPromotableMediaFeedsAsync()
{
var mediaList = new InstaMediaList();
try
{
var instaUri = UriCreator.GetPromotableMediaFeedsUri();
var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo);
var response = await _httpRequestProcessor.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaMediaList>(response, json));
}
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
mediaList = ConvertersFabric.Instance.GetMediaListConverter(mediaResponse).Convert();
mediaList.PageSize = mediaResponse.ResultsCount;
return(Result.Success(mediaList));
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail(exception, mediaList));
}
}
public async Task <IResult <InstaMediaList> > GetUserTagsAsync(string username, int maxPages = 0)
{
ValidateUser();
ValidateLoggedIn();
try
{
if (maxPages == 0)
{
maxPages = int.MaxValue;
}
var user = await GetUserAsync(username);
if (!user.Succeeded || string.IsNullOrEmpty(user.Value.Pk))
{
return(Result.Fail($"Unable to get user {username}", (InstaMediaList)null));
}
var uri = UriCreator.GetUserTagsUri(user.Value?.Pk, _user.RankToken);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, uri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
var userTags = new InstaMediaList();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.Fail("", (InstaMediaList)null));
}
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
var nextId = mediaResponse.NextMaxId;
userTags.AddRange(
mediaResponse.Medias.Select(ConvertersFabric.GetSingleMediaConverter)
.Select(converter => converter.Convert()));
var pages = 1;
while (!string.IsNullOrEmpty(nextId) && pages < maxPages)
{
uri = UriCreator.GetUserTagsUri(user.Value?.Pk, _user.RankToken, nextId);
var nextMedia = await GetUserMediaListWithMaxIdAsync(uri);
if (!nextMedia.Succeeded)
{
Result.Success($"Not all pages was downloaded: {nextMedia.Info.Message}", userTags);
}
nextId = nextMedia.Value.NextMaxId;
userTags.AddRange(
mediaResponse.Medias.Select(ConvertersFabric.GetSingleMediaConverter)
.Select(converter => converter.Convert()));
pages++;
}
return(Result.Success(userTags));
}
catch (Exception exception)
{
return(Result.Fail(exception.Message, (InstaMediaList)null));
}
}
public void SetMediaListByUserName(List <string> userNameList)
{
logger.Info("/-----Instagram Service Save Media From UserName Start-----/");
int savedCount = 0;
try
{
// 인스타 UserName 존재하면,
if (userNameList.Count > 0)
{
foreach (string userName in userNameList)
{
logger.Info("/-----UserName : "******" Save Start-----/");
PaginationParameters paginationParameters = PaginationParameters.MaxPagesToLoad(5);
InstaMediaList collections =
instaApi.UserProcessor.GetUserMediaAsync(userName, paginationParameters).Result.Value;
foreach (InstaMedia instaMedia in collections)
{
string imgUri = string.Empty;
if (instaMedia.Carousel != null)
{
imgUri = instaMedia.Carousel[0].Images[0].Uri;
}
else
{
imgUri = instaMedia.Images[0].Uri;
}
InstagramT entity = new InstagramT()
{
InstagramId = instaMedia.InstaIdentifier,
UserName = instaMedia.User.UserName,
ImageUrl = imgUri,
Url = instaMedia.Code
};
instagramRepository.InsertInstagramData(entity);
savedCount++;
}
logger.Info("/-----UserName : "******" Save End-----/");
}
}
logger.Info("/-----Instagram Service Save Media End! Saved Count : " + savedCount + " -----/");
}
catch (Exception e)
{
logger.Error(e, "Instagram Service Error");
}
}
private async Task <IResult <InstaMediaList> > GetUserShoppableMedia(long userId,
PaginationParameters paginationParameters)
{
var mediaList = new InstaMediaList();
try
{
var instaUri = UriCreator.GetUserShoppableMediaListUri(userId, paginationParameters.NextMaxId);
var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo);
var response = await _httpRequestProcessor.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaMediaList>(response, json));
}
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
mediaList = ConvertersFabric.Instance.GetMediaListConverter(mediaResponse).Convert();
mediaList.NextMaxId = paginationParameters.NextMaxId = mediaResponse.NextMaxId;
while (mediaResponse.MoreAvailable &&
!string.IsNullOrEmpty(paginationParameters.NextMaxId) &&
paginationParameters.PagesLoaded < paginationParameters.MaximumPagesToLoad)
{
paginationParameters.PagesLoaded++;
var nextMedia = await GetUserShoppableMedia(userId, paginationParameters);
if (!nextMedia.Succeeded)
{
return(Result.Fail(nextMedia.Info, mediaList));
}
mediaList.NextMaxId = paginationParameters.NextMaxId = nextMedia.Value.NextMaxId;
mediaList.AddRange(nextMedia.Value);
}
mediaList.Pages = paginationParameters.PagesLoaded;
mediaList.PageSize = mediaResponse.ResultsCount;
return(Result.Success(mediaList));
}
catch (HttpRequestException httpException)
{
_logger?.LogException(httpException);
return(Result.Fail(httpException, default(InstaMediaList), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail(exception, mediaList));
}
}
/// <summary>
/// Get user tags by username asynchronously
/// <remarks>Returns media list containing tags</remarks>
/// </summary>
/// <param name="userId">User id (pk)</param>
/// <param name="paginationParameters">Pagination parameters: next id and max amount of pages to load</param>
/// <returns>
/// <see cref="InstaMediaList" />
/// </returns>
public async Task <IResult <InstaMediaList> > GetUserTagsAsync(long userId,
PaginationParameters paginationParameters)
{
UserAuthValidator.Validate(_userAuthValidate);
var userTags = new InstaMediaList();
try
{
var uri = UriCreator.GetUserTagsUri(userId, _user.RankToken, paginationParameters.NextId);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, uri, _deviceInfo);
var response = await _httpRequestProcessor.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.Fail("", (InstaMediaList)null));
}
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
userTags.AddRange(
mediaResponse.Medias.Select(ConvertersFabric.Instance.GetSingleMediaConverter)
.Select(converter => converter.Convert()));
userTags.NextId = paginationParameters.NextId = mediaResponse.NextMaxId;
paginationParameters.PagesLoaded++;
while (mediaResponse.MoreAvailable &&
!string.IsNullOrEmpty(paginationParameters.NextId) &&
paginationParameters.PagesLoaded < paginationParameters.MaximumPagesToLoad)
{
var nextMedia = await GetUserTagsAsync(userId, paginationParameters);
if (!nextMedia.Succeeded)
{
return(nextMedia);
}
userTags.AddRange(nextMedia.Value);
userTags.NextId = paginationParameters.NextId = nextMedia.Value.NextId;
}
return(Result.Success(userTags));
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail(exception, userTags));
}
}
public LocationFeed Convert()
{
if (SourceObject == null)
{
throw new ArgumentNullException("SourceObject");
}
InstaMediaList ConvertMedia(List <InstaMediaItemResponse> mediasResponse)
{
var medias = new InstaMediaList();
if (mediasResponse == null)
{
return(medias);
}
foreach (var instaUserFeedItemResponse in mediasResponse)
{
if (instaUserFeedItemResponse?.Type != 0)
{
continue;
}
var feedItem = InstaConvertersFabric.Instance.GetSingleMediaConverter(instaUserFeedItemResponse)
.Convert();
medias.Add(feedItem);
}
return(medias);
}
var feed = new LocationFeed
{
MediaCount = SourceObject.MediaCount,
NextMaxId = SourceObject.NextMaxId,
Medias = ConvertMedia(SourceObject.Items),
RankedMedias = ConvertMedia(SourceObject.RankedItems),
Location = InstaConvertersFabric.Instance.GetLocationConverter(SourceObject.Location).Convert(),
Story = InstaConvertersFabric.Instance.GetStoryConverter(SourceObject.Story).Convert()
};
return(feed);
}
private InstaMediaList ConvertMedia(List <InstaMediaItemResponse> mediasResponse)
{
var medias = new InstaMediaList();
if (mediasResponse == null)
{
return(medias);
}
foreach (var instaUserFeedItemResponse in mediasResponse)
{
if (instaUserFeedItemResponse?.Type != 0)
{
continue;
}
var feedItem = ConvertersFabric.Instance.GetSingleMediaConverter(instaUserFeedItemResponse)
.Convert();
medias.Add(feedItem);
}
return(medias);
}
private async void UserControl_Loaded(object sender, RoutedEventArgs e)
{
try
{
var feed = await this.Api.GetLikeFeedAsync(PaginationParameters.MaxPagesToLoad(1));
if (feed.Succeeded)
{
Feed = feed.Value;
Feed.ForEach(m =>
{
pnlPosts.Children.Add(new PostView(m, Api));
});
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public InstaCollectionItem Convert()
{
var instaMediaList = new InstaMediaList();
if (SourceObject.Media != null)
{
instaMediaList.AddRange(SourceObject.Media.Medias
.Select(ConvertersFabric.Instance.GetSingleMediaConverter)
.Select(converter => converter.Convert()));
}
return(new InstaCollectionItem
{
CollectionId = SourceObject.CollectionId,
CollectionName = SourceObject.CollectionName,
HasRelatedMedia = SourceObject.HasRelatedMedia,
Media = instaMediaList,
CoverMedia = SourceObject.CoverMedia != null
? ConvertersFabric.Instance.GetCoverMediaConverter(SourceObject.CoverMedia).Convert()
: null
});
}
public void Collect_By_Profile(string ProfilesList_Path, int count = 100, string Save_Path = "./Data/ByProfile/")
{
#region Read Profile File
int index = 0;
List <List <string> > Profiles = new StreamReader(ProfilesList_Path).ReadToEnd().Split("\r\n").ToList().Split <string>(Bots.Count);
#endregion
var spw = Stopwatch.StartNew();
List <Task <Task> > TasksList = new List <Task <Task> >();
for (; index < Bots.Count; index++)
{
TasksList.Add(new Task <Task>(new Func <object, Task>(async BotIndexOBJ =>
{
int BotIndex = int.Parse(BotIndexOBJ.ToString());
#region Collect Profiles Medias
foreach (var profile in Profiles[BotIndex])
{
//Directory for instaMedias
string path = Save_Path + profile + "_" + DateTime.Now.ToFileTimeUtc();
Directory.CreateDirectory(path);
//Get instaMedias
InstaMediaList instaMedias = new InstaMediaList();
var FirstRequestResult = await Bots[BotIndex].GetUserMediaAsync(profile, PaginationParameters.MaxPagesToLoad(1));
instaMedias.AddRange(FirstRequestResult.Value);
string nextid = FirstRequestResult.Value.NextId;
while (instaMedias.Count <= count)
{
if (nextid != "")
{
var RequestResult = await Bots[BotIndex].GetUserMediaAsync(profile, PaginationParameters.MaxPagesToLoad(1).StartFromId(nextid));
if (RequestResult.Succeeded)
{
instaMedias.AddRange(RequestResult.Value);
}
nextid = RequestResult.Value.NextId;
}
else
{
break;
}
}
//Save instaMedias
using (StreamWriter sw = new StreamWriter(path + "/" + profile + "_instaMedias.json"))
{
string jsonstring = JsonConvert.SerializeObject(instaMedias, Formatting.Indented);
await sw.WriteAsync(jsonstring);
}
//Download Images
Directory.CreateDirectory(path + "/Image");
Directory.CreateDirectory(path + "/Video");
Directory.CreateDirectory(path + "/Carousel");
using (WebClient client = new WebClient())
{
foreach (var media in instaMedias)
{
switch (media.MediaType)
{
case InstaMediaType.Image:
client.DownloadFile(new Uri(media.Images[0].URI), path + "/Image/" + media.InstaIdentifier + ".jpg");
break;
case InstaMediaType.Video:
client.DownloadFile(new Uri(media.Videos[0].Url), path + "/Video/" + media.InstaIdentifier + ".mp4");
break;
case InstaMediaType.Carousel:
for (int k = 0; k < media.Carousel.Count; k++)
{
if (media.Carousel[k].Images.Count > 0)
{
client.DownloadFile(new Uri(media.Carousel[k].Images[0].URI), path + "/Carousel/" + media.InstaIdentifier + "_" + k + "_" + ".jpg");
}
if (media.Carousel[k].Videos.Count > 0)
{
client.DownloadFile(new Uri(media.Carousel[k].Videos[0].Url), path + "/Carousel/" + media.InstaIdentifier + "_" + k + "_" + ".mp4");
}
}
break;
}
}
}
Console.WriteLine($" Bot {BotIndex.ToString()} completed Profile {profile} with index {Profiles[BotIndex].IndexOf(profile)} from {Profiles[BotIndex].Count}");
}
#endregion
Console.WriteLine($" Tasks for Bot {BotIndex.ToString()} completed after {spw.Elapsed}");
}), index));
}
TasksList.ForEach(t => t.Start()); //Step A Start
TasksList.ForEach(t => t.Wait()); //Step B Wait
TasksList.ForEach(t => t.Result.Wait()); //Step C Result
Console.WriteLine(" Done !");
spw.Stop();
}
private async Task <IResult <InstaMediaList> > GetUserShoppableMedia(long userId,
PaginationParameters paginationParameters)
{
var mediaList = new InstaMediaList();
try
{
if (paginationParameters == null)
{
paginationParameters = PaginationParameters.MaxPagesToLoad(1);
}
InstaMediaList Convert(InstaMediaListResponse mediaListResponse)
{
return(ConvertersFabric.Instance.GetMediaListConverter(mediaListResponse).Convert());
}
var mediaResult = await GetShoppableMedia(userId, paginationParameters);
if (!mediaResult.Succeeded)
{
if (mediaResult.Value != null)
{
return(Result.Fail(mediaResult.Info, Convert(mediaResult.Value)));
}
else
{
return(Result.Fail(mediaResult.Info, mediaList));
}
}
var mediaResponse = mediaResult.Value;
mediaList = ConvertersFabric.Instance.GetMediaListConverter(mediaResponse).Convert();
mediaList.NextMaxId = paginationParameters.NextMaxId = mediaResponse.NextMaxId;
paginationParameters.PagesLoaded++;
while (mediaResponse.MoreAvailable &&
!string.IsNullOrEmpty(paginationParameters.NextMaxId) &&
paginationParameters.PagesLoaded < paginationParameters.MaximumPagesToLoad)
{
var nextMedia = await GetShoppableMedia(userId, paginationParameters);
if (!nextMedia.Succeeded)
{
return(Result.Fail(nextMedia.Info, mediaList));
}
mediaList.NextMaxId = paginationParameters.NextMaxId = nextMedia.Value.NextMaxId;
mediaList.AddRange(Convert(nextMedia.Value));
mediaResponse.MoreAvailable = nextMedia.Value.MoreAvailable;
mediaResponse.ResultsCount += nextMedia.Value.ResultsCount;
paginationParameters.PagesLoaded++;
}
mediaList.Pages = paginationParameters.PagesLoaded;
mediaList.PageSize = mediaResponse.ResultsCount;
return(Result.Success(mediaList));
}
catch (HttpRequestException httpException)
{
_logger?.LogException(httpException);
return(Result.Fail(httpException, default(InstaMediaList), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail(exception, mediaList));
}
}
