/// <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)); } }