/// <summary>
/// Search user people
/// </summary>
/// <param name="query">Text to search</param>
/// <param name="count">Count</param>
public async Task <IResult <InstaDiscoverSearchResult> > SearchPeopleAsync(string query, int count = 30)
{
try
{
var instaUri = InstaUriCreator.GetSearchUserUri(query, count);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaDiscoverSearchResult>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaDiscoverSearchResultResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetDiscoverSearchResultConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaDiscoverSearchResult), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaDiscoverSearchResult>(exception));
}
}
/// <summary>
/// Get stories of an hashtag
/// </summary>
/// <param name="tagName">Tag name</param>
public async Task <IResult <HashtagStory> > GetHashtagStoriesAsync(string tagName)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetHashtagStoryUri(tagName);
var request =
httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <HashtagStory>(response, json));
}
var obj = JsonConvert.DeserializeObject <HashtagStoryContainerResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetHashtagStoryConverter(obj.Story).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(HashtagStory), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <HashtagStory>(exception));
}
}
/// <summary>
/// Get location(place) information by external id or facebook places id
/// <para>
/// Get external id from this function:
/// <see cref="ILocationProcessor.SearchLocationAsync(double, double, string)" />
/// </para>
/// <para>
/// Get facebook places id from this function:
/// <see cref="ILocationProcessor.SearchPlacesAsync(double, double, string)(double, double, string)" />
/// </para>
/// </summary>
/// <param name="externalIdOrFacebookPlacesId">
/// External id or facebook places id of an location/place
/// <para>
/// Get external id from this function:
/// <see cref="ILocationProcessor.SearchLocationAsync(double, double, string)" />
/// </para>
/// <para>
/// Get facebook places id from this function:
/// <see cref="ILocationProcessor.SearchPlacesAsync(double, double, string)(double, double, string)" />
/// </para>
/// </param>
public async Task <IResult <PlaceShort> > GetLocationInfoAsync(string externalIdOrFacebookPlacesId)
{
try
{
var instaUri = InstaUriCreator.GetLocationInfoUri(externalIdOrFacebookPlacesId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <PlaceShort>(response, json));
}
var obj = JsonConvert.DeserializeObject <PlaceResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetPlaceShortConverter(obj.Location).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(PlaceShort), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <PlaceShort>(exception));
}
}
/// <summary>
/// Get media insights
/// </summary>
/// <param name="mediaPk">Media PK (<see cref="InstaMedia.Pk" />)</param>
public async Task <IResult <InstaMediaInsights> > GetMediaInsightsAsync(string mediaPk)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetMediaSingleInsightsUri(mediaPk);
var request =
httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaMediaInsights>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaMediaInsightsContainer>(json);
return(Result.Success(obj.MediaOrganicInsights));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaMediaInsights), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaMediaInsights>(exception));
}
}
private async Task <IResult <InstaCollectionItemResponse> > GetSingleCollection(
long collectionId,
PaginationParameters paginationParameters)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var collectionUri = InstaUriCreator.GetCollectionUri(collectionId, paginationParameters?.NextMaxId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, collectionUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaCollectionItemResponse>(response, json));
}
var collectionsListResponse =
JsonConvert.DeserializeObject <InstaCollectionItemResponse>(
json,
new InstaCollectionDataConverter());
return(Result.Success(collectionsListResponse));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaCollectionItemResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaCollectionItemResponse>(exception));
}
}
private async Task <IResult <InstaRecentActivityResponse> > GetFollowingActivityWithMaxIdAsync(string maxId)
{
try
{
var uri = InstaUriCreator.GetFollowingRecentActivityUri(maxId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, uri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaRecentActivityResponse>(response, json));
}
var followingActivity = JsonConvert.DeserializeObject <InstaRecentActivityResponse>(
json,
new InstaRecentActivityConverter());
return(Result.Success(followingActivity));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaRecentActivityResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaRecentActivityResponse>(exception));
}
}
/// <summary>
/// Get account details for an business account ( like it's joined date )
/// <param name="userId">User id (pk)</param>
/// </summary>
public async Task <IResult <InstaAccountDetails> > GetAccountDetailsAsync(long userId)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetAccountDetailsUri(userId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaAccountDetails>(
response,
"Can't find account details for this user pk",
json));
}
var obj = JsonConvert.DeserializeObject <InstaAccountDetailsResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetAccountDetailsConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaAccountDetails), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaAccountDetails>(exception));
}
}
/// <summary>
/// Unlike media comment
/// </summary>
/// <param name="commentId">Comment id</param>
public async Task <IResult <bool> > UnlikeCommentAsync(string commentId)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetUnLikeCommentUri(commentId);
var fields = new Dictionary <string, string>
{
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_csrftoken", user.CsrfToken }
};
var request =
httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, fields);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
return(response.StatusCode == HttpStatusCode.OK
? Result.Success(true)
: Result.UnExpectedResponse <bool>(response, json));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(bool), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail(exception, false));
}
}
/// <summary>
/// Get product info
/// </summary>
/// <param name="productId">Product id (get it from <see cref="InstaProduct.ProductId" /> )</param>
/// <param name="mediaPk">Media Pk (get it from <see cref="InstaMedia.Pk" />)</param>
/// <param name="deviceWidth">Device width (pixel)</param>
public async Task <IResult <InstaProductInfo> > GetProductInfoAsync(
long productId,
string mediaPk,
int deviceWidth = 720)
{
try
{
var instaUri = InstaUriCreator.GetProductInfoUri(productId, mediaPk, deviceWidth);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaProductInfo>(response, json));
}
var productInfoResponse = JsonConvert.DeserializeObject <InstaProductInfoResponse>(json);
var converted = InstaConvertersFabric.Instance.GetProductInfoConverter(productInfoResponse).Convert();
return(Result.Success(converted));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaProductInfo), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaProductInfo>(exception));
}
}
/// <summary>
/// Clear Recent searches
/// </summary>
public async Task <IResult <bool> > ClearRecentSearchsAsync()
{
try
{
var instaUri = InstaUriCreator.GetClearSearchHistoryUri();
var data = new JObject
{
{ "_csrftoken", user.CsrfToken }, { "_uuid", deviceInfo.DeviceGuid.ToString() }
};
var request = httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <bool>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaDefault>(json);
return(obj.Status == "ok" ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(bool), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <bool>(exception));
}
}
private async Task <IResult <InstaTagFeedResponse> > GetTagFeed(string tag,
PaginationParameters paginationParameters)
{
try
{
var userFeedUri = InstaUriCreator.GetTagFeedUri(tag, paginationParameters?.NextMaxId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, userFeedUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaTagFeedResponse>(response, json));
}
var feedResponse = JsonConvert.DeserializeObject <InstaTagFeedResponse>(
json,
new InstaTagFeedDataConverter());
return(Result.Success(feedResponse));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaTagFeedResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail(exception, default(InstaTagFeedResponse)));
}
}
/// <summary>
/// Gets the stories of particular location.
/// </summary>
/// <param name="locationId">Location identifier (location pk, external id, facebook id)</param>
/// <returns>
/// Location stories
/// </returns>
public async Task <IResult <InstaStory> > GetLocationStoriesAsync(long locationId)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var uri = InstaUriCreator.GetLocationFeedUri(locationId.ToString());
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, uri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaStory>(response, json));
}
var feedResponse = JsonConvert.DeserializeObject <LocationFeedResponse>(json);
var feed = InstaConvertersFabric.Instance.GetLocationFeedConverter(feedResponse).Convert();
return(Result.Success(feed.Story));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaStory), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaStory>(exception));
}
}
/// <summary>
/// Get top searches
/// </summary>
/// <param name="querry">querry string of the search</param>
/// <param name="searchType">Search type(only blended and users works)</param>
/// <param name="timezoneOffset">
/// Timezone offset of the search region (GMT Offset * 60 * 60 - Like Tehran GMT +3:30 = 3.5*
/// 60*60 = 12600)
/// </param>
/// <returns></returns>
public async Task <IResult <InstaDiscoverTopSearches> > GetTopSearchesAsync(
string querry = "",
InstaDiscoverSearchType searchType = InstaDiscoverSearchType.Users,
int timezoneOffset = 12600)
{
try
{
var instaUri = InstaUriCreator.GetTopSearchUri(user.RankToken, querry, searchType, timezoneOffset);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaDiscoverTopSearches>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaDiscoverTopSearchesResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetDiscoverTopSearchesConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaDiscoverTopSearches), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaDiscoverTopSearches>(exception));
}
}
/// <summary>
/// Get recent activity info asynchronously
/// </summary>
/// <param name="paginationParameters">Pagination parameters: next id and max amount of pages to load</param>
/// <returns>
/// <see cref="T:InstagramApiSharp.Classes.Models.InstaActivityFeed" />
/// </returns>
public Task <IResult <InstaActivityFeed> > GetRecentActivityFeedAsync(
PaginationParameters paginationParameters)
{
InstaUserAuthValidator.Validate(userAuthValidate);
var uri = InstaUriCreator.GetRecentActivityUri();
return(GetRecentActivityInternalAsync(uri, paginationParameters));
}
/// <summary>
/// Searches for specific location by provided geo-data or search query.
/// </summary>
/// <param name="latitude">Latitude</param>
/// <param name="longitude">Longitude</param>
/// <param name="query">Search query</param>
/// <returns>
/// List of locations (short format)
/// </returns>
public async Task <IResult <LocationShortList> > SearchLocationAsync(double latitude, double longitude, string query)
{
logger.LogDebug("SearchLocationAsync {0} {1} {2}", latitude, longitude, query);
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var uri = InstaUriCreator.GetLocationSearchUri();
var fields = new Dictionary <string, string>
{
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_csrftoken", user.CsrfToken },
{ "latitude", latitude.ToString(CultureInfo.InvariantCulture) },
{ "longitude", longitude.ToString(CultureInfo.InvariantCulture) },
{ "rank_token", user.RankToken }
};
if (!string.IsNullOrEmpty(query))
{
fields.Add("search_query", query);
}
else
{
fields.Add("timestamp", InstaDateTimeHelper.GetUnixTimestampSeconds().ToString());
}
if (!Uri.TryCreate(uri, fields.AsQueryString(), out var newuri))
{
return(Result.Fail <LocationShortList>("Unable to create uri for location search"));
}
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, newuri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <LocationShortList>(response, json));
}
var locations = JsonConvert.DeserializeObject <LocationSearchResponse>(json);
var converter = InstaConvertersFabric.Instance.GetLocationsSearchConverter(locations);
return(Result.Success(converter.Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(LocationShortList), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <LocationShortList>(exception));
}
}
/// <summary>
/// Get suggested categories
/// </summary>
public async Task <IResult <InstaBusinessSuggestedCategoryList> > GetSuggestedCategoriesAsync()
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetBusinessGraphQlUri();
var zero = new JObject {
{ "page_name", user.UserName.ToLower() }, { "num_result", "5" }
};
var queryParams = new JObject {
{ "0", zero }
};
var data = new Dictionary <string, string>
{
{ "query_id", "706774002864790" },
{ "locale", InstaApiConstants.AcceptLanguage.Replace("-", "_") },
{ "vc_policy", "ads_viewer_context_policy" },
{ "signed_body", $"{httpHelper.ApiVersion.SignatureKey}." },
{
InstaApiConstants.HeaderIgSignatureKeyVersion,
InstaApiConstants.IgSignatureKeyVersion
},
{ "strip_nulls", "true" },
{ "strip_defaults", "true" },
{ "query_params", queryParams.ToString(Formatting.None) }
};
var request =
httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaBusinessSuggestedCategoryList>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaBusinessSuggestedCategoryList>(
json,
new InstaBusinessSuggestedCategoryDataConverter());
return(Result.Success(obj));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException,
default(InstaBusinessSuggestedCategoryList),
ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaBusinessSuggestedCategoryList>(exception));
}
}
/// <summary>
/// Search city location for business account
/// </summary>
/// <param name="cityOrTown">City/town name</param>
public async Task <IResult <InstaBusinessCityLocationList> > SearchCityLocationAsync(string cityOrTown)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
if (string.IsNullOrEmpty(cityOrTown))
{
return(Result.Fail <InstaBusinessCityLocationList>("CityOrTown cannot be null or empty"));
}
var instaUri = InstaUriCreator.GetBusinessGraphQlUri();
var queryParams = new JObject {
{ "0", cityOrTown }
};
var data = new Dictionary <string, string>
{
{ "query_id", "1860980127555904" },
{ "locale", InstaApiConstants.AcceptLanguage.Replace("-", "_") },
{ "vc_policy", "ads_viewer_context_policy" },
{ "signed_body", $"{httpHelper.ApiVersion.SignatureKey}." },
{
InstaApiConstants.HeaderIgSignatureKeyVersion,
InstaApiConstants.IgSignatureKeyVersion
},
{ "strip_nulls", "true" },
{ "strip_defaults", "true" },
{ "query_params", queryParams.ToString(Formatting.None) }
};
var request =
httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaBusinessCityLocationList>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaBusinessCityLocationList>(
json,
new InstaBusinessCityLocationDataConverter());
return(Result.Success(obj));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaBusinessCityLocationList), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaBusinessCityLocationList>(exception));
}
}
/// <summary>
/// Search user by location
/// </summary>
/// <param name="latitude">Latitude</param>
/// <param name="longitude">Longitude</param>
/// <param name="desireUsername">Desire username</param>
/// <param name="count">Maximum user count</param>
public async Task <IResult <InstaUserSearchLocation> > SearchUserByLocationAsync(
double latitude,
double longitude,
string desireUsername,
int count = 50)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var uri = InstaUriCreator.GetUserSearchByLocationUri();
if (count <= 0)
{
count = 30;
}
var fields = new Dictionary <string, string>
{
{ "timezone_offset", InstaApiConstants.TimezoneOffset.ToString() },
{ "lat", latitude.ToString(CultureInfo.InvariantCulture) },
{ "lng", longitude.ToString(CultureInfo.InvariantCulture) },
{ "count", count.ToString() },
{ "query", desireUsername },
{ "context", "blended" },
{ "rank_token", user.RankToken }
};
if (!Uri.TryCreate(uri, fields.AsQueryString(), out var newuri))
{
return(Result.Fail <InstaUserSearchLocation>("Unable to create uri for user search by location"));
}
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, newuri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaUserSearchLocation>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaUserSearchLocation>(json);
return(obj.Status.ToLower() == "ok"
? Result.Success(obj)
: Result.UnExpectedResponse <InstaUserSearchLocation>(response, json));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaUserSearchLocation), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaUserSearchLocation>(exception));
}
}
/// <summary>
/// Edit a collection
/// </summary>
/// <param name="collectionId">Collection ID to edit</param>
/// <param name="name">New name for giving collection (set null if you don't want to change it)</param>
/// <param name="photoCoverMediaId">
/// New photo cover media Id (get it from <see cref="InstaMedia.Identifier" />) => Optional
/// <para>Important note: media id must be exists in giving collection!</para>
/// </param>
public async Task <IResult <InstaCollectionItem> > EditCollectionAsync(
long collectionId,
string name,
string photoCoverMediaId = null)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var collection = await GetSingleCollection(collectionId, PaginationParameters.MaxPagesToLoad(1)).ConfigureAwait(false);
if (collection.Succeeded && string.IsNullOrEmpty(name))
{
name = collection.Value.CollectionName;
}
var editCollectionUri = InstaUriCreator.GetEditCollectionUri(collectionId);
var data = new JObject
{
{ "name", name ?? string.Empty },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "_uid", user.LoggedInUser.Pk },
{ "_csrftoken", user.CsrfToken }
};
if (!string.IsNullOrEmpty(photoCoverMediaId))
{
data.Add("cover_media_id", photoCoverMediaId);
}
var request =
httpHelper.GetSignedRequest(HttpMethod.Get, editCollectionUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaCollectionItem>(response, json));
}
var newCollectionResponse = JsonConvert.DeserializeObject <InstaCollectionItemResponse>(json);
var converter = InstaConvertersFabric.Instance.GetCollectionConverter(newCollectionResponse);
return(Result.Success(converter.Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaCollectionItem), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaCollectionItem>(exception));
}
}
private async Task <IResult <PlaceListResponse> > SearchPlaces(
double latitude,
double longitude,
string query,
PaginationParameters paginationParameters)
{
try
{
if (paginationParameters == null)
{
paginationParameters = PaginationParameters.MaxPagesToLoad(1);
}
var instaUri = InstaUriCreator.GetSearchPlacesUri(
InstaApiConstants.TimezoneOffset,
latitude,
longitude,
query,
paginationParameters.NextMaxId,
paginationParameters.ExcludeList);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var obj = JsonConvert.DeserializeObject <PlaceListResponse>(json);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <PlaceListResponse>(response, json));
}
if (obj.Items?.Count > 0)
{
foreach (var item in obj.Items)
{
obj.ExcludeList.Add(item.Location.Pk);
}
}
return(Result.Success(obj));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(PlaceListResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <PlaceListResponse>(exception));
}
}
private async Task <IResult <SectionMediaListResponse> > GetHashtagSection(string tagName, string rankToken = null, string maxId = null, bool recent = false)
{
try
{
var instaUri = InstaUriCreator.GetHashtagSectionUri(tagName);
var data = new Dictionary <string, string>
{
{ "_csrftoken", user.CsrfToken },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "include_persistent", !recent ? "true" : "false" },
{ "rank_token", rankToken }
};
if (recent)
{
data.Add("tab", "recent");
}
else
{
data.Add("supported_tabs", new JArray("top", "recent", "places", "discover").ToString());
}
if (!string.IsNullOrEmpty(maxId))
{
data.Add("max_id", maxId);
}
var request = httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <SectionMediaListResponse>(response, json));
}
var obj = JsonConvert.DeserializeObject <SectionMediaListResponse>(json);
return(Result.Success(obj));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(SectionMediaListResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <SectionMediaListResponse>(exception));
}
}
/// <summary>
/// Searches for specific hashtag by search query.
/// </summary>
/// <param name="query">Search query</param>
/// <param name="excludeList">
/// Array of numerical hashtag IDs (ie "17841562498105353") to exclude from the response,
/// allowing you to skip tags from a previous call to get more results
/// </param>
/// <param name="rankToken">The rank token from the previous page's response</param>
/// <returns>
/// List of hashtags
/// </returns>
public async Task <IResult <HashtagSearch> > SearchHashtagAsync(string query, IEnumerable <long> excludeList, string rankToken)
{
InstaUserAuthValidator.Validate(userAuthValidate);
var requestHeaderFieldsTooLarge = (HttpStatusCode)431;
var count = 50;
var tags = new HashtagSearch();
try
{
var userUri = InstaUriCreator.GetSearchTagUri(query, count, excludeList, rankToken);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, userUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode == requestHeaderFieldsTooLarge)
{
return(Result.Success(tags));
}
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <HashtagSearch>(response, json));
}
var tagsResponse = JsonConvert.DeserializeObject <HashtagSearchResponse>(
json,
new InstaHashtagSearchDataConverter());
tags = InstaConvertersFabric.Instance.GetHashTagsSearchConverter(tagsResponse).Convert();
if (tags.Any() && excludeList != null && excludeList.Contains(tags.First().Id))
{
tags.RemoveAt(0);
}
if (!tags.Any())
{
tags = new HashtagSearch();
}
return(Result.Success(tags));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(HashtagSearch), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail(exception, tags));
}
}
private async Task <IResult <InstaTvChannel> > GetChannel(InstaTvChannelType?channelType,
long?userId,
PaginationParameters paginationParameters)
{
try
{
var instaUri = InstaUriCreator.GetIgtvChannelUri();
var data = new JObject
{
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_csrftoken", user.CsrfToken }
};
if (channelType != null)
{
data.Add("id", channelType.Value.GetRealChannelType());
}
else
{
data.Add("id", $"user_{userId}");
}
if (paginationParameters != null && !string.IsNullOrEmpty(paginationParameters.NextMaxId))
{
data.Add("max_id", paginationParameters.NextMaxId);
}
var request = httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaTvChannel>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaTvChannelResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetTvChannelConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaTvChannel), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaTvChannel>(exception));
}
}
/// <summary>
/// Inline comment media
/// </summary>
/// <param name="mediaId">Media id</param>
/// <param name="targetCommentId">Target comment id</param>
/// <param name="text">Comment text</param>
public async Task <IResult <InstaComment> > ReplyCommentMediaAsync(
string mediaId,
string targetCommentId,
string text)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetPostCommetUri(mediaId);
var breadcrumb = InstaCryptoHelper.GetCommentBreadCrumbEncoded(text);
var fields = new Dictionary <string, string>
{
{ "user_breadcrumb", breadcrumb },
{ "idempotence_token", Guid.NewGuid().ToString() },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "replied_to_comment_id", targetCommentId },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_csrftoken", user.CsrfToken },
{ "comment_text", text },
{ "containermodule", "comments_feed_timeline" },
{ "radio_type", "wifi-none" }
};
var request =
httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, fields);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaComment>(response, json));
}
var commentResponse = JsonConvert.DeserializeObject <InstaCommentResponse>(
json,
new InstaCommentDataConverter());
var converter = InstaConvertersFabric.Instance.GetCommentConverter(commentResponse);
return(Result.Success(converter.Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaComment), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaComment>(exception));
}
}
/// <summary>
/// Adds items to collection asynchronous.
/// </summary>
/// <param name="collectionId">Collection identifier.</param>
/// <param name="mediaIds">Media id list.</param>
public async Task <IResult <InstaCollectionItem> > AddItemsToCollectionAsync(
long collectionId,
params string[] mediaIds)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
if (mediaIds?.Length < 1)
{
return(Result.Fail <InstaCollectionItem>("Provide at least one media id to add to collection"));
}
var editCollectionUri = InstaUriCreator.GetEditCollectionUri(collectionId);
var data = new JObject
{
{ "module_name", InstaApiConstants.FeedSavedAddToCollectionModule },
{ "added_media_ids", JsonConvert.SerializeObject(mediaIds) },
{ "radio_type", "wifi-none" },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "_uid", user.LoggedInUser.Pk },
{ "_csrftoken", user.CsrfToken }
};
var request =
httpHelper.GetSignedRequest(HttpMethod.Get, editCollectionUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaCollectionItem>(response, json));
}
var newCollectionResponse = JsonConvert.DeserializeObject <InstaCollectionItemResponse>(json);
var converter = InstaConvertersFabric.Instance.GetCollectionConverter(newCollectionResponse);
return(Result.Success(converter.Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaCollectionItem), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaCollectionItem>(exception));
}
}
/// <summary>
/// Get statistics of current account
/// </summary>
public async Task <IResult <InstaStatistics> > GetStatisticsAsync()
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
var instaUri = InstaUriCreator.GetGraphStatisticsUri(InstaApiConstants.AcceptLanguage);
var queryParamsData = new JObject
{
{ "access_token", "" }, { "id", user.LoggedInUser.Pk.ToString() }
};
var variables = new JObject
{
{ "query_params", queryParamsData },
{ "timezone", InstaApiConstants.Timezone },
{ "activityTab", true },
{ "audienceTab", true },
{ "contentTab", true }
};
var data = new Dictionary <string, string>
{
{ "access_token", "undefined" },
{ "fb_api_caller_class", "RelayModern" },
{ "variables", variables.ToString(Formatting.None) },
{ "doc_id", "1926322010754880" }
};
var request =
httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaStatistics>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaStatisticsRootResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetStatisticsConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaStatistics), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaStatistics>(exception));
}
}
/// <summary>
/// Validate an uri for an button(instagram partner)
/// <para>
/// Note: Use <see cref="IBusinessProcessor.GetBusinessPartnersButtonsAsync" /> to get business buttons(instagram
/// partner) list!
/// </para>
/// </summary>
/// <param name="desirePartner">
/// Desire partner (Use <see cref="IBusinessProcessor.GetBusinessPartnersButtonsAsync" /> to
/// get business buttons(instagram partner) list!)
/// </param>
/// <param name="uri">Uri to check (Must be related to desire partner!)</param>
public async Task <IResult <bool> > ValidateUrlAsync(InstaBusinessPartner desirePartner, Uri uri)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
if (desirePartner?.AppId == null)
{
return(Result.Fail <bool>("Desire partner cannot be null"));
}
if (uri == null)
{
return(Result.Fail <bool>("Uri cannot be null"));
}
var instaUri = InstaUriCreator.GetBusinessValidateUrlUri();
var data = new JObject
{
{ "app_id", desirePartner.AppId },
{ "_csrftoken", user.CsrfToken },
{ "url", uri.ToString() },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_uuid", deviceInfo.DeviceGuid.ToString() }
};
var request =
httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var obj = JsonConvert.DeserializeObject <InstaBusinessValidateUrl>(json);
return(obj.IsValid ? Result.Success(true) : Result.Fail <bool>(obj.ErrorMessage));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(bool), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <bool>(exception));
}
}
private async Task <IResult <InstaTopicalExploreFeedResponse> > GetTopicalExploreFeed(
PaginationParameters paginationParameters,
string clusterId)
{
try
{
if (string.IsNullOrEmpty(clusterId))
{
clusterId = "explore_all:0";
}
var exploreUri =
InstaUriCreator.GetTopicalExploreUri(deviceInfo.GoogleAdId.ToString(),
paginationParameters?.NextMaxId,
clusterId);
var request = httpHelper.GetDefaultRequest(HttpMethod.Get, exploreUri, deviceInfo);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaTopicalExploreFeedResponse>(response, json));
}
var feedResponse = JsonConvert.DeserializeObject <InstaTopicalExploreFeedResponse>(
json,
new InstaTopicalExploreFeedDataConverter());
return(Result.Success(feedResponse));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException,
default(InstaTopicalExploreFeedResponse),
ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaTopicalExploreFeedResponse>(exception));
}
}
/// <summary>
/// NOT COMPLETE
/// </summary>
/// <returns></returns>
private async Task <IResult <object> > DiscoverPeopleAsync()
{
try
{
var instaUri = InstaUriCreator.GetDiscoverPeopleUri();
Debug.WriteLine(instaUri.ToString());
var data = new JObject
{
{ "phone_id", deviceInfo.DeviceGuid.ToString() },
{ "module", "discover_people" },
{ "_csrftoken", user.CsrfToken },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "paginate", "true" }
//{"_uid", _user.LoggedInUder.Pk.ToString()},
};
var request = httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, data);
request.Headers.Host = "i.instagram.com";
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
Debug.WriteLine(json);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaDefaultResponse>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaDefaultResponse>(json);
return(Result.Success(obj));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaDefaultResponse), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaDefaultResponse>(exception));
}
}
/// <summary>
/// Change business category
/// <para>Note: Get it from <see cref="IBusinessProcessor.GetSubCategoriesAsync(string)" /></para>
/// </summary>
/// <param name="subCategoryId">
/// Sub category id (Get it from <see cref="IBusinessProcessor.GetSubCategoriesAsync(string)" />)
/// </param>
public async Task <IResult <InstaBusinessUser> > ChangeBusinessCategoryAsync(string subCategoryId)
{
InstaUserAuthValidator.Validate(userAuthValidate);
try
{
if (string.IsNullOrEmpty(subCategoryId))
{
return(Result.Fail <InstaBusinessUser>("Sub category id cannot be null or empty"));
}
var instaUri = InstaUriCreator.GetSetBusinessCategoryUri();
var data = new JObject
{
{ "_csrftoken", user.CsrfToken },
{ "_uid", user.LoggedInUser.Pk.ToString() },
{ "_uuid", deviceInfo.DeviceGuid.ToString() },
{ "category_id", subCategoryId }
};
var request =
httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, deviceInfo, data);
var response = await httpRequestProcessor.SendAsync(request).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.StatusCode != HttpStatusCode.OK)
{
return(Result.UnExpectedResponse <InstaBusinessUser>(response, json));
}
var obj = JsonConvert.DeserializeObject <InstaBusinessUserContainerResponse>(json);
return(Result.Success(InstaConvertersFabric.Instance.GetBusinessUserConverter(obj).Convert()));
}
catch (HttpRequestException httpException)
{
logger?.LogError(httpException, "Error");
return(Result.Fail(httpException, default(InstaBusinessUser), ResponseType.NetworkProblem));
}
catch (Exception exception)
{
logger?.LogError(exception, "Error");
return(Result.Fail <InstaBusinessUser>(exception));
}
}
