/// <summary> /// Get TV Guide (gets popular and suggested channels) /// </summary> public async Task <IResult <InstaTV> > GetTVGuideAsync() { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetIGTVGuideUri(); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); Debug.WriteLine(json); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaTV>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaTV>(json); return(Result.Success(obj)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaTV>(exception.Message)); } }
/// <summary> /// Get your collections /// </summary> /// <returns> /// <see cref="T:InstagramApiSharp.Classes.Models.InstaCollections" /> /// </returns> public async Task <IResult <InstaCollections> > GetCollectionsAsync() { UserAuthValidator.Validate(_userAuthValidate); try { var collectionUri = UriCreator.GetCollectionsUri(); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, collectionUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaCollections>(response, json)); } var collectionsResponse = JsonConvert.DeserializeObject <InstaCollectionsResponse>(json); var converter = ConvertersFabric.Instance.GetCollectionsConverter(collectionsResponse); return(Result.Success(converter.Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaCollections>(exception.Message)); } }
/// <summary> /// Get suggested hashtags /// </summary> /// <returns> /// List of hashtags /// </returns> public async Task <IResult <InstaHashtagSearch> > GetSuggestedHashtagsAsync() { UserAuthValidator.Validate(_userAuthValidate); var tags = new InstaHashtagSearch(); try { var userUri = UriCreator.GetSuggestedTagsUri(); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, userUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaHashtagSearch>(response, json)); } var tagsResponse = JsonConvert.DeserializeObject <InstaHashtagSearchResponse>(json, new InstaHashtagSuggestedDataConverter()); tags = ConvertersFabric.Instance.GetHashTagsSearchConverter(tagsResponse).Convert(); return(Result.Success(tags)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail(exception, tags)); } }
/// <summary> /// Gets the hashtag information by user tagname. /// </summary> /// <param name="tagname">Tagname</param> /// <returns>Hashtag information</returns> public async Task <IResult <InstaHashtag> > GetHashtagInfoAsync(string tagname) { UserAuthValidator.Validate(_userAuthValidate); try { var userUri = UriCreator.GetTagInfoUri(tagname); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, userUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaHashtag>(response, json)); } var tagInfoResponse = JsonConvert.DeserializeObject <InstaHashtagResponse>(json); var tagInfo = ConvertersFabric.Instance.GetHashTagConverter(tagInfoResponse).Convert(); return(Result.Success(tagInfo)); } catch (HttpRequestException httpException) { _logger?.LogException(httpException); return(Result.Fail(httpException, default(InstaHashtag), ResponseType.NetworkProblem)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaHashtag>(exception)); } }
/// <summary> /// Create a new collection /// </summary> /// <param name="collectionName">The name of the new collection</param> /// <returns> /// <see cref="T:InstagramApiSharp.Classes.Models.InstaCollectionItem" /> /// </returns> public async Task <IResult <InstaCollectionItem> > CreateCollectionAsync(string collectionName) { UserAuthValidator.Validate(_userAuthValidate); try { var createCollectionUri = UriCreator.GetCreateCollectionUri(); var data = new JObject { { "_uuid", _deviceInfo.DeviceGuid.ToString() }, { "_uid", _user.LoggedInUser.Pk }, { "_csrftoken", _user.CsrfToken }, { "name", collectionName }, { "module_name", InstaApiConstants.COLLECTION_CREATE_MODULE } }; var request = _httpHelper.GetSignedRequest(HttpMethod.Get, createCollectionUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); var newCollectionResponse = JsonConvert.DeserializeObject <InstaCollectionItemResponse>(json); var converter = ConvertersFabric.Instance.GetCollectionConverter(newCollectionResponse); return(response.StatusCode != HttpStatusCode.OK ? Result.UnExpectedResponse <InstaCollectionItem>(response, json) : Result.Success(converter.Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaCollectionItem>(exception.Message)); } }
/// <summary> /// Delete a media (photo or video) /// </summary> /// <param name="mediaId">The media ID</param> /// <param name="mediaType">The type of the media</param> /// <returns>Return true if the media is deleted</returns> public async Task <IResult <bool> > DeleteMediaAsync(string mediaId, InstaMediaType mediaType) { UserAuthValidator.Validate(_userAuthValidate); try { var deleteMediaUri = UriCreator.GetDeleteMediaUri(mediaId, mediaType); var data = new JObject { { "_uuid", _deviceInfo.DeviceGuid.ToString() }, { "_uid", _user.LoggedInUser.Pk }, { "_csrftoken", _user.CsrfToken }, { "media_id", mediaId } }; var request = HttpHelper.GetSignedRequest(HttpMethod.Get, deleteMediaUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <bool>(response, json)); } var deletedResponse = JsonConvert.DeserializeObject <DeleteResponse>(json); return(Result.Success(deletedResponse.IsDeleted)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <bool>(exception)); } }
/// <summary> /// Get media by its id asynchronously /// </summary> /// <param name="mediaId">Maximum count of pages to retrieve</param> /// <returns> /// <see cref="InstaMedia" /> /// </returns> public async Task <IResult <InstaMedia> > GetMediaByIdAsync(string mediaId) { UserAuthValidator.Validate(_userAuthValidate); try { var mediaUri = UriCreator.GetMediaUri(mediaId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, mediaUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaMedia>(response, json)); } var mediaResponse = JsonConvert.DeserializeObject <InstaMediaListResponse>(json, new InstaMediaListDataConverter()); if (mediaResponse.Medias?.Count > 1) { var errorMessage = $"Got wrong media count for request with media id={mediaId}"; _logger?.LogInfo(errorMessage); return(Result.Fail <InstaMedia>(errorMessage)); } var converter = ConvertersFabric.Instance.GetSingleMediaConverter(mediaResponse.Medias.FirstOrDefault()); return(Result.Success(converter.Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaMedia>(exception)); } }
public UserServiceTest() { var options = new DbContextOptionsBuilder <DBContext>() .UseInMemoryDatabase("DataUserMemory"); Environment.SetEnvironmentVariable("CryptographyKey", "CryptographySecretKeyValue"); var tokenConfigurations = new TokenConfigurations(); var signingConfigurations = new SigningConfigurations(); var config = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build(); new ConfigureFromConfigurationOptions <TokenConfigurations>( config.GetSection("TokenConfigurations")).Configure(tokenConfigurations); var dbContext = new DBContext(options.Options); var authenticationService = new AuthHelper(signingConfigurations, tokenConfigurations); var userAuthValidator = new UserAuthValidator(); var helper = new Helper(); var userContext = new UserContext <UserDTO>(dbContext); var userValidator = new UserValidator(); _userService = new UserService(authenticationService, userAuthValidator, helper, userContext, userValidator); }
/// <summary> /// Get pending friendship requests. /// </summary> public async Task <IResult <InstaPendingRequest> > GetPendingFriendRequestsAsync() { UserAuthValidator.Validate(_userAuthValidate); try { var cookies = _httpRequestProcessor.HttpHandler.CookieContainer.GetCookies(_httpRequestProcessor.Client .BaseAddress); var csrftoken = cookies[InstaApiConstants.CSRFTOKEN]?.Value ?? string.Empty; _user.CsrfToken = csrftoken; var instaUri = UriCreator.GetFriendshipPendingRequestsUri(_user.RankToken); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo); request.Properties.Add(InstaApiConstants.HEADER_IG_SIGNATURE_KEY_VERSION, InstaApiConstants.IG_SIGNATURE_KEY_VERSION); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.OK) { var JRes = JsonConvert.DeserializeObject <InstaPendingRequest>(json); return(Result.Success(JRes)); } return(Result.Fail <InstaPendingRequest>(response.StatusCode.ToString())); } catch (Exception ex) { return(Result.Fail <InstaPendingRequest>(ex.Message)); } }
/// <summary> /// Get your collections /// </summary> /// <param name="paginationParameters">Pagination parameters: next max id and max amount of pages to load</param> /// <returns> /// <see cref="T:InstagramApiSharp.Classes.Models.InstaCollections" /> /// </returns> public async Task <IResult <InstaCollections> > GetCollectionsAsync(PaginationParameters paginationParameters) { UserAuthValidator.Validate(_userAuthValidate); try { if (paginationParameters == null) { paginationParameters = PaginationParameters.MaxPagesToLoad(1); } InstaCollections Convert(InstaCollectionsResponse instaCollectionsResponse) { return(ConvertersFabric.Instance.GetCollectionsConverter(instaCollectionsResponse).Convert()); } var collections = await GetCollections(paginationParameters); if (!collections.Succeeded) { return(Result.Fail(collections.Info, default(InstaCollections))); } var collectionsResponse = collections.Value; paginationParameters.NextMaxId = collectionsResponse.NextMaxId; var pagesLoaded = 1; while (collectionsResponse.MoreAvailable && !string.IsNullOrEmpty(collectionsResponse.NextMaxId) && pagesLoaded < paginationParameters.MaximumPagesToLoad) { var nextCollection = await GetCollections(paginationParameters); if (!nextCollection.Succeeded) { return(Result.Fail(nextCollection.Info, Convert(nextCollection.Value))); } collectionsResponse.NextMaxId = paginationParameters.NextMaxId = nextCollection.Value.NextMaxId; collectionsResponse.MoreAvailable = nextCollection.Value.MoreAvailable; collectionsResponse.AutoLoadMoreEnabled = nextCollection.Value.AutoLoadMoreEnabled; collectionsResponse.Status = nextCollection.Value.Status; collectionsResponse.Items.AddRange(nextCollection.Value.Items); pagesLoaded++; } var converter = ConvertersFabric.Instance.GetCollectionsConverter(collectionsResponse); return(Result.Success(converter.Convert())); } catch (HttpRequestException httpException) { _logger?.LogException(httpException); return(Result.Fail(httpException, default(InstaCollections), ResponseType.NetworkProblem)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaCollections>(exception)); } }
private async Task <IResult <InstaCollectionItemResponse> > GetSingleCollection(long collectionId, PaginationParameters paginationParameters) { UserAuthValidator.Validate(_userAuthValidate); try { var collectionUri = UriCreator.GetCollectionUri(collectionId, paginationParameters?.NextMaxId); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, collectionUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); 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?.LogException(httpException); return(Result.Fail(httpException, default(InstaCollectionItemResponse), ResponseType.NetworkProblem)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaCollectionItemResponse>(exception)); } }
/// <summary> /// Get story media viewers /// </summary> /// <param name="StoryMediaId">Story media id</param> /// <param name="paginationParameters">Pagination parameters</param> public async Task <IResult <InstaReelStoryMediaViewers> > GetStoryMediaViewers(string StoryMediaId, PaginationParameters paginationParameters) { UserAuthValidator.Validate(_userAuthValidate); try { if (paginationParameters.MaximumPagesToLoad > 1) { throw new Exception("Not supported"); } var directInboxUri = new Uri(InstaApiConstants.BASE_INSTAGRAM_API_URL + $"media/{StoryMediaId}/list_reel_media_viewer/?max_id={paginationParameters.NextId}", UriKind.RelativeOrAbsolute); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, directInboxUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaReelStoryMediaViewers>(response, json)); } var threadResponse = JsonConvert.DeserializeObject <InstaReelStoryMediaViewers>(json); return(Result.Success(threadResponse)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaReelStoryMediaViewers>(exception.Message)); } }
/// <summary> /// Get user story reel feed. Contains user info last story including all story items. /// </summary> /// <param name="userId">User identifier (PK)</param> public async Task <IResult <InstaReelFeed> > GetUserStoryFeedAsync(long userId) { UserAuthValidator.Validate(_userAuthValidate); var feed = new InstaReelFeed(); try { var userFeedUri = UriCreator.GetUserReelFeedUri(userId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, userFeedUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaReelFeed>(response, json)); } var feedResponse = JsonConvert.DeserializeObject <InstaReelFeedResponse>(json); feed = ConvertersFabric.Instance.GetReelFeedConverter(feedResponse).Convert(); return(Result.Success(feed)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail(exception.Message, feed)); } }
/// <summary> /// Get user story feed (stories from users followed by current user). /// </summary> public async Task <IResult <InstaStoryFeed> > GetStoryFeedAsync() { UserAuthValidator.Validate(_userAuthValidate); try { var storyFeedUri = UriCreator.GetStoryFeedUri(); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, storyFeedUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); Debug.WriteLine(json); if (response.StatusCode != HttpStatusCode.OK) { return(Result.Fail("", (InstaStoryFeed)null)); } var storyFeedResponse = JsonConvert.DeserializeObject <InstaStoryFeedResponse>(json); var instaStoryFeed = ConvertersFabric.Instance.GetStoryFeedConverter(storyFeedResponse).Convert(); return(Result.Success(instaStoryFeed)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaStoryFeed>(exception.Message)); } }
/// <summary> /// Leave from group thread /// </summary> /// <param name="threadId">Thread id</param> public async Task <IResult <bool> > LeaveGroupThreadAsync(string threadId) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetLeaveThreadUri(threadId); var clientContext = Guid.NewGuid().ToString(); var data = new Dictionary <string, string> { { "_csrftoken", _user.CsrfToken }, { "_uuid", _deviceInfo.DeviceGuid.ToString() }, }; var request = _httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); //Debug.WriteLine(json); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <bool>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaDefault>(json); return(obj.Status.ToLower() == "ok" ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <bool>(exception)); } }
/// <summary> /// Ignore user friendship requst. /// </summary> /// <param name="userId">User id (pk)</param> public async Task <IResult <InstaFriendshipStatus> > IgnoreFriendshipRequestAsync(long userId) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetDenyFriendshipUri(userId); var fields = new Dictionary <string, string> { { "user_id", userId.ToString() }, { "_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); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaFriendshipStatus>(response, json)); } var JRes = JsonConvert.DeserializeObject <InstaFriendshipStatus>(json); return(Result.Success(JRes)); } catch (Exception ex) { return(Result.Fail <InstaFriendshipStatus>(ex.Message)); } }
/// <summary> /// Edit the caption of the media (photo/video) /// </summary> /// <param name="mediaId">The media ID</param> /// <param name="caption">The new caption</param> /// <returns>Return true if everything is ok</returns> public async Task <IResult <bool> > EditMediaAsync(string mediaId, string caption) { UserAuthValidator.Validate(_userAuthValidate); try { var editMediaUri = UriCreator.GetEditMediaUri(mediaId); var data = new JObject { { "_uuid", _deviceInfo.DeviceGuid.ToString() }, { "_uid", _user.LoggedInUser.Pk }, { "_csrftoken", _user.CsrfToken }, { "caption_text", caption } }; var request = HttpHelper.GetSignedRequest(HttpMethod.Get, editMediaUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.OK) { return(Result.Success(true)); } var error = JsonConvert.DeserializeObject <BadStatusResponse>(json); return(Result.Fail(error.Message, false)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <bool>(exception)); } }
/// <summary> /// Report user /// </summary> /// <param name="userId">User id (pk)</param> public async Task <IResult <bool> > ReportUserAsync(long userId) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetReportUserUri(userId); var fields = new Dictionary <string, string> { { "user_id", userId.ToString() }, { "source_name", "profile" }, { "reason", "1" }, { "_uuid", _deviceInfo.DeviceGuid.ToString() }, { "_uid", _user.LoggedInUser.Pk.ToString() }, { "_csrftoken", _user.CsrfToken }, { "is_spam", "true" } }; var request = _httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, _deviceInfo, fields); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); return(response.StatusCode == HttpStatusCode.OK ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail(exception.Message, false)); } }
/// <summary> /// Get users (short) who liked certain media. Normaly it return around 1000 last users. /// </summary> /// <param name="mediaId">Media id</param> public async Task <IResult <InstaLikersList> > GetMediaLikersAsync(string mediaId) { UserAuthValidator.Validate(_userAuthValidate); try { var likers = new InstaLikersList(); var likersUri = UriCreator.GetMediaLikersUri(mediaId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, likersUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaLikersList>(response, json)); } var mediaLikersResponse = JsonConvert.DeserializeObject <InstaMediaLikersResponse>(json); likers.UsersCount = mediaLikersResponse.UsersCount; if (mediaLikersResponse.UsersCount < 1) { return(Result.Success(likers)); } likers.AddRange( mediaLikersResponse.Users.Select(ConvertersFabric.Instance.GetUserShortConverter) .Select(converter => converter.Convert())); return(Result.Success(likers)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaLikersList>(exception)); } }
/// <summary> /// Sync your phone contact list to instagram /// <para>Note:You can find your friends in instagram with this function</para> /// </summary> /// <param name="instaContacts">Contact list</param> public async Task <IResult <InstaContactUserList> > SyncContactsAsync(InstaContactList instaContacts) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetSyncContactsUri(); var jsonContacts = JsonConvert.SerializeObject(instaContacts); var fields = new Dictionary <string, string> { { "contacts", jsonContacts } }; var request = _httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, _deviceInfo, fields); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaContactUserList>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaContactUserListResponse>(json); return(Result.Success(ConvertersFabric.Instance.GetUserContactListConverter(obj).Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaContactUserList>(exception)); } }
/// <summary> /// Get share link from media Id /// </summary> /// <param name="mediaId">media ID</param> /// <returns>Share link as Uri</returns> public async Task <IResult <Uri> > GetShareLinkFromMediaIdAsync(string mediaId) { UserAuthValidator.Validate(_userAuthValidate); try { var collectionUri = UriCreator.GetShareLinkFromMediaId(mediaId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, collectionUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <Uri>(response, json)); } var data = JsonConvert.DeserializeObject <InstaPermalinkResponse>(json); return(Result.Success(new Uri(data.Permalink))); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <Uri>(exception.Message)); } }
/// <summary> /// Get media inline comments /// </summary> /// <param name="mediaId">Media id</param> /// <param name="targetCommentId">Target comment id</param> /// <param name="paginationParameters">Maximum amount of pages to load and start id</param> /// <returns></returns> public async Task <IResult <InstaInlineCommentList> > GetMediaRepliesCommentsAsync(string mediaId, string targetCommentId, PaginationParameters paginationParameters) { UserAuthValidator.Validate(_userAuthValidate); try { var commentsUri = UriCreator.GetMediaInlineCommentsUri(mediaId, targetCommentId, paginationParameters.NextId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, commentsUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaInlineCommentList>(response, json)); } var commentListResponse = JsonConvert.DeserializeObject <InstaInlineCommentListResponse>(json); var pagesLoaded = 1; InstaInlineCommentList Convert(InstaInlineCommentListResponse commentsResponse) { return(ConvertersFabric.Instance.GetInlineCommentsConverter(commentsResponse).Convert()); } while (commentListResponse.HasMoreTailChildComments && !string.IsNullOrEmpty(commentListResponse.NextMaxId) && pagesLoaded < paginationParameters.MaximumPagesToLoad || commentListResponse.HasMoreHeadChildComments && !string.IsNullOrEmpty(commentListResponse.NextMinId) && pagesLoaded < paginationParameters.MaximumPagesToLoad) { IResult <InstaInlineCommentListResponse> nextComments; if (!string.IsNullOrEmpty(commentListResponse.NextMaxId)) { nextComments = await GetInlineCommentListWithMaxIdAsync(mediaId, targetCommentId, commentListResponse.NextMaxId, null); } else { nextComments = await GetInlineCommentListWithMaxIdAsync(mediaId, targetCommentId, null, commentListResponse.NextMinId); } if (!nextComments.Succeeded) { return(Result.Fail(nextComments.Info, Convert(commentListResponse))); } commentListResponse.NextMaxId = nextComments.Value.NextMaxId; commentListResponse.NextMinId = nextComments.Value.NextMinId; commentListResponse.HasMoreHeadChildComments = nextComments.Value.HasMoreHeadChildComments; commentListResponse.HasMoreTailChildComments = nextComments.Value.HasMoreTailChildComments; commentListResponse.ChildComments.AddRange(nextComments.Value.ChildComments); pagesLoaded++; } var comments = ConvertersFabric.Instance.GetInlineCommentsConverter(commentListResponse).Convert(); return(Result.Success(comments)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaInlineCommentList>(exception)); } }
/// <summary> /// Get direct inbox thread by its id asynchronously /// </summary> /// <param name="threadId">Thread id</param> /// <returns> /// <see cref="InstaDirectInboxThread" /> /// </returns> public async Task <IResult <InstaDirectInboxThread> > GetDirectInboxThreadAsync(string threadId, string nextOrCursorId = "") { UserAuthValidator.Validate(_userAuthValidate); try { var directInboxUri = UriCreator.GetDirectInboxThreadUri(threadId, nextOrCursorId); var request = HttpHelper.GetDefaultRequest(HttpMethod.Get, directInboxUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaDirectInboxThread>(response, json)); } var threadResponse = JsonConvert.DeserializeObject <InstaDirectInboxThreadResponse>(json, new InstaThreadDataConverter()); //Reverse for Chat Order threadResponse.Items.Reverse(); // var converter = ConvertersFabric.Instance.GetDirectThreadConverter(threadResponse); return(Result.Success(converter.Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaDirectInboxThread>(exception.Message)); } }
/// <summary> /// Delete media comment /// </summary> /// <param name="mediaId">Media id</param> /// <param name="commentId">Comment id</param> public async Task <IResult <bool> > DeleteCommentAsync(string mediaId, string commentId) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetDeleteCommentUri(mediaId, 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); var json = await response.Content.ReadAsStringAsync(); return(response.StatusCode == HttpStatusCode.OK ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail(exception.Message, false)); } }
/// <summary> /// Delete your collection for given collection id /// </summary> /// <param name="collectionId">Collection ID to delete</param> /// <returns>true if succeed</returns> public async Task <IResult <bool> > DeleteCollectionAsync(long collectionId) { UserAuthValidator.Validate(_userAuthValidate); try { var createCollectionUri = UriCreator.GetDeleteCollectionUri(collectionId); var data = new JObject { { "_uuid", _deviceInfo.DeviceGuid.ToString() }, { "_uid", _user.LoggedInUser.Pk }, { "_csrftoken", _user.CsrfToken }, { "module_name", "collection_editor" } }; var request = _httpHelper.GetSignedRequest(HttpMethod.Get, createCollectionUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.OK) { return(Result.Success(true)); } var error = JsonConvert.DeserializeObject <BadStatusResponse>(json); return(Result.Fail(error.Message, false)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail(exception.Message, false)); } }
/// <summary> /// Get direct inbox threads for current user asynchronously /// </summary> /// <returns> /// <see cref="T:InstagramApiSharp.Classes.Models.InstaDirectInboxContainer" /> /// </returns> public async Task <IResult <InstaDirectInboxContainer> > GetDirectInboxAsync(string nextOrCursorId = "") { UserAuthValidator.Validate(_userAuthValidate); try { var directInboxUri = UriCreator.GetDirectInboxUri(nextOrCursorId); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, directInboxUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); //Debug.WriteLine(json); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaDirectInboxContainer>(response, json)); } var inboxResponse = JsonConvert.DeserializeObject <InstaDirectInboxContainerResponse>(json); return(Result.Success(ConvertersFabric.Instance.GetDirectInboxConverter(inboxResponse).Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaDirectInboxContainer>(exception.Message)); } }
/// <summary> /// Get stories of an hashtag /// </summary> /// <param name="tagname">Tag name</param> public async Task <IResult <InstaHashtagStory> > GetHashtagStoriesAsync(string tagname) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetHashtagStoryUri(tagname); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaHashtagStory>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaHashtagStoryContainerResponse>(json); return(Result.Success(ConvertersFabric.Instance.GetHashtagStoryConverter(obj.Story).Convert())); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaHashtagStory>(exception)); } }
/// <summary> /// Send profile to direct thrad /// </summary> /// <param name="userIdToSend">User id to send</param> /// <param name="threadIds">Thread ids</param> public async Task <IResult <bool> > SendDirectProfileAsync(long userIdToSend, params string[] threadIds) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetSendDirectProfileUri(); var clientContext = Guid.NewGuid().ToString(); var data = new Dictionary <string, string> { { "profile_user_id", userIdToSend.ToString() }, { "action", "send_item" }, { "thread_ids", $"[{threadIds.EncodeList(false)}]" }, { "client_context", clientContext }, { "_csrftoken", _user.CsrfToken }, { "_uuid", _deviceInfo.DeviceGuid.ToString() } }; var request = _httpHelper.GetDefaultRequest(HttpMethod.Post, instaUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <bool>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaDefault>(json); return(obj.Status.ToLower() == "ok" ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <bool>(exception)); } }
/// <summary> /// Follow a hashtag /// </summary> /// <param name="tagname">Tag name</param> public async Task <IResult <bool> > FollowHashtagAsync(string tagname) { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetFollowHashtagUri(tagname); var data = new JObject { { "_csrftoken", _user.CsrfToken }, { "_uid", _user.LoggedInUser.Pk.ToString() }, { "_uuid", _deviceInfo.DeviceGuid.ToString() }, }; var request = _httpHelper.GetSignedRequest(HttpMethod.Post, instaUri, _deviceInfo, data); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <bool>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaDefault>(json); return(obj.Status.ToLower() == "ok" ? Result.Success(true) : Result.UnExpectedResponse <bool>(response, json)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <bool>(exception)); } }
/// <summary> /// Get branded content approval settings /// <para>Note: Only approved partners can tag you in branded content when you require approvals.</para> /// </summary> public async Task <IResult <InstaBrandedContent> > GetBrandedContentApprovalAsync() { UserAuthValidator.Validate(_userAuthValidate); try { var instaUri = UriCreator.GetBusinessBrandedSettingsUri(); var request = _httpHelper.GetDefaultRequest(HttpMethod.Get, instaUri, _deviceInfo); var response = await _httpRequestProcessor.SendAsync(request); var json = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { return(Result.UnExpectedResponse <InstaBrandedContent>(response, json)); } var obj = JsonConvert.DeserializeObject <InstaBrandedContentResponse>(json); return(Result.Success(ConvertersFabric.Instance.GetBrandedContentConverter(obj).Convert())); } catch (HttpRequestException httpException) { _logger?.LogException(httpException); return(Result.Fail(httpException, default(InstaBrandedContent), ResponseType.NetworkProblem)); } catch (Exception exception) { _logger?.LogException(exception); return(Result.Fail <InstaBrandedContent>(exception)); } }