/// <summary>
        ///		Get the comments on a gallery submission.
        /// </summary>
        /// <param name="id">The id of the gallery submission to fetch the comments for.</param>
        /// <param name="sort">How to sort the comments.</param>
        /// <exception cref="ArgumentNullException">Thrown when id was null or empty.</exception>
        /// <exception cref="ImgurException">Thrown when Imgur encountered an error.</exception>
        /// <returns>The comments posted to the gallery submission.</returns>
        public async Task<ICollection<IComment>> GetCommentsAsync(string id, CommentSortOrder sort)
        {
            if (string.IsNullOrEmpty(id))
                throw new ArgumentNullException(nameof(id));

            var sortStr = sort.ToString().ToLower();
            var url = $"gallery/{id}/comments/{sortStr}";

            using (var request = RequestBuilder.CreateRequest(HttpMethod.Get, url))
            {
                var comments = await SendRequestAsync<Comment[]>(request);
                return comments;
            }
        }
Beispiel #2
0
        /// <summary>
        ///		Get the comments on a gallery submission.
        /// </summary>
        /// <param name="id">The id of the gallery submission to fetch the comments for.</param>
        /// <param name="sort">How to sort the comments.</param>
        /// <exception cref="ArgumentNullException">Thrown when id was null or empty.</exception>
        /// <exception cref="ImgurException">Thrown when Imgur encountered an error.</exception>
        /// <returns>The comments posted to the gallery submission.</returns>
        public async Task <ICollection <IComment> > GetCommentsAsync(string id, CommentSortOrder sort)
        {
            if (string.IsNullOrEmpty(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            var sortStr = sort.ToString().ToLower();
            var url     = $"gallery/{id}/comments/{sortStr}";

            using (var request = RequestBuilder.CreateRequest(HttpMethod.Get, url))
            {
                var comments = await SendRequestAsync <Comment[]>(request);

                return(comments);
            }
        }
        /// <summary>
        ///     Return the comments the user has created.
        /// </summary>
        /// <param name="username">The user account. Default: me</param>
        /// <param name="sort">'best', 'worst', 'oldest', or 'newest'. Defaults to 'newest'.</param>
        /// <param name="page">Allows you to set the page number so you don't have to retrieve all the data at once.</param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="ImgurException"></exception>
        /// <exception cref="MashapeException"></exception>
        /// <exception cref="OverflowException"></exception>
        /// <returns></returns>
        public async Task<ICollection<IComment>> GetCommentsAsync(string username = "******",
            CommentSortOrder? sort = CommentSortOrder.Newest, int? page = null)
        {
            if (string.IsNullOrEmpty(username))
                throw new ArgumentNullException(nameof(username));

            if (username.Equals("me", StringComparison.OrdinalIgnoreCase)
                && ApiClient.OAuth2Token == null)
                throw new ArgumentNullException(nameof(ApiClient.OAuth2Token), OAuth2RequiredExceptionMessage);

            var sortValue = $"{sort ?? CommentSortOrder.Newest}".ToLower();
            var url = $"account/{username}/comments/{sortValue}/{page}";

            using (var request = CommentRequestBuilder.CreateRequest(HttpMethod.Get, url))
            {
                var comments = await SendRequestAsync<Comment[]>(request);
                return comments;
            }
        }
        /// <summary>
        ///     Get all comments for a gallery item.
        /// </summary>
        /// <param name="galleryItemId">The gallery item id.</param>
        /// <param name="sort">The order that comments should be sorted by.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown when a null reference is passed to a method that does not accept it as a
        ///     valid argument.
        /// </exception>
        /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception>
        /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception>
        /// <returns></returns>
        public async Task<IEnumerable<IComment>> GetGalleryItemCommentsAsync(string galleryItemId,
            CommentSortOrder? sort = CommentSortOrder.Best)
        {
            if (string.IsNullOrWhiteSpace(galleryItemId))
                throw new ArgumentNullException(nameof(galleryItemId));

            sort = sort ?? CommentSortOrder.Best;

            var sortValue = $"{sort}".ToLower();
            var url = $"gallery/{galleryItemId}/comments/{sortValue}";

            using (var request = RequestBuilder.CreateRequest(HttpMethod.Get, url))
            {
                var comments = await SendRequestAsync<IEnumerable<Comment>>(request).ConfigureAwait(false);
                return comments;
            }
        }
        /// <summary>
        /// 排序
        /// </summary>
        /// <param name="sort"></param>
        /// <returns></returns>
        private static Func <IQueryable <CommentEntity>, IOrderedQueryable <CommentEntity> > GetOrder(CommentSortOrder sort)
        {
            Func <IQueryable <CommentEntity>, IOrderedQueryable <CommentEntity> > order = null;

            switch (sort)
            {
            case CommentSortOrder.Default:
            default:
                order = v => v.OrderByDescending(s => s.CreatedDate);
                break;
            }

            return(order);
        }
 public List <CommentEntity> GetList(int pageSize, CommentSortOrder sort, Timestamp timestamp, int sourceId, SourceType sourceType)
 {
     return(base.Get(GetFilter(timestamp, sourceId, sourceType), GetOrder(sort)).Take(pageSize).ToList());
 }
 public List <CommentEntity> GetPagedList(int pageIndex, int pageSize, out int totalCount, CommentSortOrder sort, Timestamp timestamp,
                                          int sourceId, SourceType sourceType)
 {
     return(base.Get(GetFilter(timestamp, sourceId, sourceType), out totalCount, pageIndex, pageSize, GetOrder(sort)).ToList());
 }
 public List <CommentEntity> GetPagedList(PagerRequest pagerRequest, out int totalCount, CommentSortOrder sortOrder, int?sourceId,
                                          SourceType sourceType, int?userId)
 {
     return
         (base.Get(Filter(DataStatus.Normal, null, sourceId, sourceType, userId), out totalCount, pagerRequest.PageIndex,
                   pagerRequest.PageSize, GetOrder(sortOrder)).ToList());
 }
 public List <CommentEntity> GetPagedList(PagerRequest pagerRequest, out int totalCount, CommentSortOrder sortOrder)
 {
     return(GetPagedList(pagerRequest.PageIndex, pagerRequest.PageSize, out totalCount, sortOrder,
                         new Timestamp()));
 }