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