public async Task <InstaPostList> GetUserPostsByUsernameAsync(string username, int pageCount = 0)
{
var posts = new InstaPostList();
string mediaUrl = $"{InstaApiConstants.INSTAGRAM_URL}{username}{InstaApiConstants.MEDIA}";
string json;
var stream = await _httpClient.GetStreamAsync(mediaUrl);
using (var reader = new StreamReader(stream))
{
json = reader.ReadToEnd();
}
var instaresponse = JsonConvert.DeserializeObject <InstaResponse>(json);
var converter = ConvertersFabric.GetPostsConverter(instaresponse);
posts.AddRange(converter.Convert());
var pages = 1;
while (instaresponse.MoreAvailable && pages <= pageCount)
{
pages++;
instaresponse = _getUserPostsResponseWithMaxId(instaresponse.GetLastId());
converter = ConvertersFabric.GetPostsConverter(instaresponse);
posts.AddRange(converter.Convert());
}
return(posts);
}
public async Task <IResult <InstaDirectInboxThread> > GetDirectInboxThreadAsync(string threadId)
{
ValidateUser();
ValidateLoggedIn();
try
{
var directInboxUri = UriCreator.GetDirectInboxThreadUri(threadId);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, directInboxUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.Fail("", (InstaDirectInboxThread)null));
}
var threadResponse = JsonConvert.DeserializeObject <InstaDirectInboxThreadResponse>(json,
new InstaThreadDataConverter());
var converter = ConvertersFabric.GetDirectThreadConverter(threadResponse);
return(Result.Success(converter.Convert()));
}
catch (Exception exception)
{
return(Result.Fail <InstaDirectInboxThread>(exception));
}
}
public async Task <IResult <InstaUser> > GetCurrentUserAsync()
{
ValidateUser();
ValidateLoggedIn();
var instaUri = UriCreator.GetCurrentUserUri();
dynamic jsonObject = new JObject();
jsonObject._uuid = _deviceInfo.DeviceGuid;
jsonObject._uid = _user.LoggedInUder.Pk;
jsonObject._csrftoken = _user.CsrfToken;
var fields = new Dictionary <string, string>
{
{ "_uuid", _deviceInfo.DeviceGuid.ToString() },
{ "_uid", _user.LoggedInUder.Pk },
{ "_csrftoken", _user.CsrfToken }
};
var request = HttpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, _deviceInfo);
request.Content = new FormUrlEncodedContent(fields);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var user = JsonConvert.DeserializeObject <InstaCurrentUserResponse>(json);
var converter = ConvertersFabric.GetUserConverter(user.User);
var userConverted = converter.Convert();
return(Result.Success(userConverted));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaUser)null));
}
public async Task <IResult <InstaFeed> > GetTagFeedAsync(string tag, int maxPages = 0)
{
ValidateUser();
ValidateLoggedIn();
var userFeedUri = UriCreator.GetTagFeedUri(tag);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, userFeedUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var feedResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
var converter = ConvertersFabric.GetMediaListConverter(feedResponse);
var tagFeed = new InstaFeed();
tagFeed.Medias.AddRange(converter.Convert());
var nextId = feedResponse.NextMaxId;
while (feedResponse.MoreAvailable && tagFeed.Pages < maxPages)
{
var nextMedia = await GetTagFeedWithMaxIdAsync(tag, nextId);
if (!nextMedia.Succeeded)
{
Result.Success($"Not all pages was downloaded: {nextMedia.Info.Message}", tagFeed);
}
nextId = nextMedia.Value.NextMaxId;
converter = ConvertersFabric.GetMediaListConverter(nextMedia.Value);
tagFeed.Medias.AddRange(converter.Convert());
tagFeed.Pages++;
}
return(Result.Success(tagFeed));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaFeed)null));
}
public async Task <IResult <InstaUser> > GetUserAsync(string username)
{
ValidateUser();
var userUri = UriCreator.GetUserUri(username);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, userUri, _deviceInfo);
request.Properties.Add(new KeyValuePair <string, object>(InstaApiConstants.HEADER_TIMEZONE,
InstaApiConstants.TIMEZONE_OFFSET.ToString()));
request.Properties.Add(new KeyValuePair <string, object>(InstaApiConstants.HEADER_COUNT, "1"));
request.Properties.Add(new KeyValuePair <string, object>(InstaApiConstants.HEADER_RANK_TOKEN, _user.RankToken));
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var userInfo = JsonConvert.DeserializeObject <InstaSearchUserResponse>(json);
var user = userInfo.Users?.FirstOrDefault(u => u.UserName == username);
if (user == null)
{
string errorMessage = $"Can't find this user: {username}";
_logger.Write(errorMessage);
return(Result.Fail <InstaUser>(errorMessage));
}
var converter = ConvertersFabric.GetUserConverter(user);
return(Result.Success(converter.Convert()));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaUser)null));
}
public async Task <InstaUser> GetUserAsync(string username)
{
string userUrl = $"{InstaApiConstants.INSTAGRAM_URL}{username}{InstaApiConstants.GET_ALL_POSTFIX}";
IObjectConverter <InstaUser, InstaResponseUser> converter = null;
var stream = await _httpClient.GetStreamAsync(userUrl);
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
var root = JObject.Parse(json);
var userObject = root["user"];
var instaresponse = JsonConvert.DeserializeObject <InstaResponseUser>(userObject.ToString());
converter = ConvertersFabric.GetUserConverter(instaresponse);
}
return(converter.Convert());
}
public async Task <IResult <InstaRecipients> > GetRankedRecipientsAsync()
{
var userUri = UriCreator.GetRankedRecipientsUri();
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, userUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var responseRecipients = JsonConvert.DeserializeObject <InstaRecipientsResponse>(json,
new InstaRecipientsDataConverter("ranked_recipients"));
var converter = ConvertersFabric.GetRecipientsConverter(responseRecipients);
return(Result.Success(converter.Convert()));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaRecipients)null));
}
public async Task <InstaMedia> GetMediaByCodeAsync(string postCode)
{
string mediaUrl =
$"{InstaApiConstants.INSTAGRAM_URL}{InstaApiConstants.P_SUFFIX}{postCode}{InstaApiConstants.GET_ALL_POSTFIX}";
var stream = await _httpClient.GetStreamAsync(mediaUrl);
InstaResponseMedia mediaResponse;
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
var root = JObject.Parse(json);
var mediaObject = root["media"];
mediaResponse = JsonConvert.DeserializeObject <InstaResponseMedia>(mediaObject.ToString());
}
var converter = ConvertersFabric.GetSingleMediaConverter(mediaResponse);
return(converter.Convert());
}
public async Task <IResult <InstaFeed> > GetUserTimelineFeedAsync(int maxPages = 0)
{
ValidateUser();
ValidateLoggedIn();
var userFeedUri = UriCreator.GetUserFeedUri();
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, userFeedUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
var feed = new InstaFeed();
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaFeed)null));
}
var feedResponse = JsonConvert.DeserializeObject <InstaFeedResponse>(json,
new InstaFeedResponseDataConverter());
var converter = ConvertersFabric.GetFeedConverter(feedResponse);
var feedConverted = converter.Convert();
feed.Medias.AddRange(feedConverted.Medias);
var nextId = feedResponse.NextMaxId;
while (feedResponse.MoreAvailable && feed.Pages < maxPages)
{
if (string.IsNullOrEmpty(nextId))
{
break;
}
var nextFeed = await GetUserFeedWithMaxIdAsync(nextId);
if (!nextFeed.Succeeded)
{
Result.Success($"Not all pages was downloaded: {nextFeed.Info.Message}", feed);
}
nextId = nextFeed.Value.NextMaxId;
feed.Medias.AddRange(
nextFeed.Value.Items.Select(ConvertersFabric.GetSingleMediaConverter).Select(conv => conv.Convert()));
feed.Pages++;
}
return(Result.Success(feed));
}
public async Task <InstaUserFeed> GetUserFeedAsync(int pageCount)
{
if (!IsUserAuthenticated)
{
throw new Exception("user must be authenticated");
}
var feedUrl = $"{InstaApiConstants.INSTAGRAM_URL.TrimEnd('/')}{InstaApiConstants.GET_ALL_POSTFIX}";
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, new Uri(feedUrl));
request.Headers.Add(InstaApiConstants.HEADER_XCSRFToken, _user.Token);
request.Headers.Add(InstaApiConstants.HEADER_XInstagramAJAX, "1");
request.Headers.Add(InstaApiConstants.HEADER_XRequestedWith, InstaApiConstants.HEADER_XMLHttpRequest);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
var feedResponse = JsonConvert.DeserializeObject <InstaFeedResponse>(json);
var converter = ConvertersFabric.GetFeedConverter(feedResponse);
return(converter.Convert());
}
public async Task <IResult <InstaMediaList> > GetUserMediaAsync(string username, int maxPages = 0)
{
ValidateUser();
if (maxPages == 0)
{
maxPages = int.MaxValue;
}
var user = GetUser(username).Value;
var instaUri = UriCreator.GetUserMediaListUri(user.Pk);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
var converter = ConvertersFabric.GetMediaListConverter(mediaResponse);
var mediaList = converter.Convert();
var nextId = mediaResponse.NextMaxId;
while (mediaResponse.MoreAvailable && mediaList.Pages < maxPages)
{
instaUri = UriCreator.GetMediaListWithMaxIdUri(user.Pk, nextId);
var nextMedia = await GetUserMediaListWithMaxIdAsync(instaUri);
if (!nextMedia.Succeeded)
{
Result.Success($"Not all pages was downloaded: {nextMedia.Info.Message}", mediaList);
}
nextId = nextMedia.Value.NextMaxId;
mediaList.AddRange(converter.Convert());
mediaList.Pages++;
}
return(Result.Success(mediaList));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaMediaList)null));
}
public async Task <IResult <InstaMedia> > GetMediaByCodeAsync(string mediaCode)
{
ValidateUser();
var mediaUri = UriCreator.GetMediaUri(mediaCode);
var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, mediaUri, _deviceInfo);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json,
new InstaMediaListDataConverter());
if (mediaResponse.Medias?.Count != 1)
{
string errorMessage = $"Got wrong media count for request with media id={mediaCode}";
_logger.Write(errorMessage);
return(Result.Fail <InstaMedia>(errorMessage));
}
var converter = ConvertersFabric.GetSingleMediaConverter(mediaResponse.Medias.FirstOrDefault());
return(Result.Success(converter.Convert()));
}
return(Result.Fail(GetBadStatusFromJsonString(json).Message, (InstaMedia)null));
}
public async Task <IResult <bool> > LoginAsync()
{
ValidateUser();
ValidateRequestMessage();
try
{
var csrftoken = string.Empty;
var firstResponse = await _httpClient.GetAsync(_httpClient.BaseAddress);
var cookies = _httpHandler.CookieContainer.GetCookies(_httpClient.BaseAddress);
foreach (Cookie cookie in cookies)
{
if (cookie.Name == InstaApiConstants.CSRFTOKEN)
{
csrftoken = cookie.Value;
}
}
_user.CsrfToken = csrftoken;
var instaUri = UriCreator.GetLoginUri();
var signature = $"{_requestMessage.GenerateSignature()}.{_requestMessage.GetMessageString()}";
var fields = new Dictionary <string, string>
{
{ InstaApiConstants.HEADER_IG_SIGNATURE, signature },
{ InstaApiConstants.HEADER_IG_SIGNATURE_KEY_VERSION, InstaApiConstants.IG_SIGNATURE_KEY_VERSION }
};
var request = HttpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, _deviceInfo);
request.Content = new FormUrlEncodedContent(fields);
request.Properties.Add(InstaApiConstants.HEADER_IG_SIGNATURE, signature);
request.Properties.Add(InstaApiConstants.HEADER_IG_SIGNATURE_KEY_VERSION,
InstaApiConstants.IG_SIGNATURE_KEY_VERSION);
var response = await _httpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
var loginInfo =
JsonConvert.DeserializeObject <InstaLoginResponse>(json);
IsUserAuthenticated = loginInfo.User != null && loginInfo.User.UserName == _user.UserName;
var converter = ConvertersFabric.GetUserConverter(loginInfo.User);
_user.LoggedInUder = converter.Convert();
_user.RankToken = $"{_user.LoggedInUder.Pk}_{_requestMessage.phone_id}";
return(Result.Success(true));
}
else
{
var loginInfo = GetBadStatusFromJsonString(json);
if (loginInfo.ErrorType == "checkpoint_logged_out")
{
return(Result.Fail("Please go to instagram.com and confirm checkpoint",
ResponseType.CheckPointRequired, false));
}
if (loginInfo.ErrorType == "login_required")
{
return(Result.Fail("Please go to instagram.com and check if you account marked as unsafe",
ResponseType.LoginRequired, false));
}
if (loginInfo.ErrorType == "Sorry, too many requests.Please try again later")
{
return(Result.Fail("Please try again later, maximum amount of requests reached",
ResponseType.LoginRequired, false));
}
return(Result.Fail(loginInfo.Message, false));
}
}
catch (Exception exception)
{
return(Result.Fail(exception.Message, false));
}
}
