-- | Copyright: (c) 2021 The closed eye of love
-- SPDX-License-Identifier: BSD-3-Clause
-- Maintainer: Poscat <poscat@mail.poscat.moe>, berberman <berberman@yandex.com>
-- Stability: alpha
-- Portability: portable
-- Functions to access pixiv api. They are supposed to be run in "Web.Pixiv.Types.PixivT".
--
-- You may notice that except 'getUserBookmarks', many of functions take a @page@ as input.
-- This is because each query contains 30 entries (except 'Web.Pixiv.API.getSpotlightArticles''s , which containes 10), i.e. you should pass @2@ if you want items ranged from 31 to 60.
module Web.Pixiv.API
  ( -- * Trending
    getTrendingTags,
    getRecommendedIllusts,
    getRecommendedMangas,

    -- * Illust
    getIllustDetail,
    getIllustComments,
    getIllustRelated,
    getIllustRanking,
    getIllustFollow,
    getIllustNew,
    getUgoiraMetadata,

    -- * Search
    searchIllust,
    searchUser,

    -- * User
    getUserDetail,
    getUserIllusts,
    getUserFollowing,
    getUserFollower,
    getUserMypixiv,
    getUserBookmarks,

    -- * Article
    getSpotlightArticles,
  )
where

import Control.Lens
import Data.Coerce (coerce)
import Data.Proxy
import Data.Text (Text)
import qualified Data.Text as T
import Data.Text.Read (decimal)
import Servant.Client.Core
import Web.Pixiv.API.Article
import Web.Pixiv.API.Illust
import Web.Pixiv.API.PixivEntry (pageToOffset)
import Web.Pixiv.API.Search
import Web.Pixiv.API.Trending
import Web.Pixiv.API.User
import Web.Pixiv.Types
import Web.Pixiv.Types.PixivT

-----------------------------------------------------------------------------

-- | Gets trending tags.
getTrendingTags ::
  MonadPixiv m =>
  -- | includes translated tag results
  Maybe Bool ->
  m [TrendingTag]
getTrendingTags :: Maybe Bool -> m [TrendingTag]
getTrendingTags Maybe Bool
includeTranslatedTagResults = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  TrendingTags
tags <- Proxy GetTrendingTags
-> Proxy m -> (Token, Maybe Text) -> Maybe Bool -> m TrendingTags
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetTrendingTags
forall k (t :: k). Proxy t
Proxy @GetTrendingTags) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe Bool
includeTranslatedTagResults
  [TrendingTag] -> m [TrendingTag]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([TrendingTag] -> m [TrendingTag])
-> [TrendingTag] -> m [TrendingTag]
forall a b. (a -> b) -> a -> b
$ TrendingTags -> [TrendingTag]
coerce TrendingTags
tags

-- | Gets recommended illustrations of the account which is used for login.
getRecommendedIllusts ::
  MonadPixiv m =>
  -- | includes privacy policy
  Maybe Bool ->
  -- | includes translated tag results
  Maybe Bool ->
  m [Illust]
getRecommendedIllusts :: Maybe Bool -> Maybe Bool -> m [Illust]
getRecommendedIllusts Maybe Bool
includePrivacyPolicy Maybe Bool
includeTranslatedTagResults = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetRecommendedIllusts
-> Proxy m
-> (Token, Maybe Text)
-> Maybe Bool
-> Maybe Bool
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetRecommendedIllusts
forall k (t :: k). Proxy t
Proxy @GetRecommendedIllusts) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe Bool
includePrivacyPolicy Maybe Bool
includeTranslatedTagResults
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Gets recommended mangas of the account which is used for login.
getRecommendedMangas :: MonadPixiv m => Maybe Bool -> Maybe Bool -> m [Illust]
getRecommendedMangas :: Maybe Bool -> Maybe Bool -> m [Illust]
getRecommendedMangas Maybe Bool
includePrivacyPolicy Maybe Bool
includeTranslatedTagResults = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetRecommendedMangas
-> Proxy m
-> (Token, Maybe Text)
-> Maybe Bool
-> Maybe Bool
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetRecommendedMangas
forall k (t :: k). Proxy t
Proxy @GetRecommendedMangas) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe Bool
includePrivacyPolicy Maybe Bool
includeTranslatedTagResults
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-----------------------------------------------------------------------------

-- | Gets the details of a illustration.
getIllustDetail ::
  MonadPixiv m =>
  -- | illust id
  Int ->
  m Illust
getIllustDetail :: Int -> m Illust
getIllustDetail Int
illustId = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  IllustWrapper
detail <- Proxy GetIllustDetail
-> Proxy m -> (Token, Maybe Text) -> Int -> m IllustWrapper
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustDetail
forall k (t :: k). Proxy t
Proxy @GetIllustDetail) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
illustId
  Illust -> m Illust
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Illust -> m Illust) -> Illust -> m Illust
forall a b. (a -> b) -> a -> b
$ IllustWrapper -> Illust
coerce IllustWrapper
detail

-- | Gets the comments of a illustration.
getIllustComments ::
  MonadPixiv m =>
  -- | illust id
  Int ->
  -- | page
  Int ->
  m Comments
getIllustComments :: Int -> Int -> m Comments
getIllustComments Int
illustId (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Proxy GetIllustComments
-> Proxy m -> (Token, Maybe Text) -> Int -> Maybe Int -> m Comments
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustComments
forall k (t :: k). Proxy t
Proxy @GetIllustComments) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
illustId Maybe Int
offset

-- | Gets related illustrations.
getIllustRelated ::
  MonadPixiv m =>
  -- | illust id
  Int ->
  -- | page
  Int ->
  m [Illust]
getIllustRelated :: Int -> Int -> m [Illust]
getIllustRelated Int
illustId (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetIllustRelated
-> Proxy m -> (Token, Maybe Text) -> Int -> Maybe Int -> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustRelated
forall k (t :: k). Proxy t
Proxy @GetIllustRelated) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
illustId Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Gets ranking illustrations.
getIllustRanking ::
  MonadPixiv m =>
  -- | rank mode
  Maybe RankMode ->
  -- | page
  Int ->
  m [Illust]
getIllustRanking :: Maybe RankMode -> Int -> m [Illust]
getIllustRanking Maybe RankMode
mode (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetIllustRanking
-> Proxy m
-> (Token, Maybe Text)
-> Maybe RankMode
-> Maybe Int
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustRanking
forall k (t :: k). Proxy t
Proxy @GetIllustRanking) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe RankMode
mode Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Gets illustrations of artists which the login account follows.
getIllustFollow ::
  MonadPixiv m =>
  -- | restrict
  Publicity ->
  -- | page
  Int ->
  m [Illust]
getIllustFollow :: Publicity -> Int -> m [Illust]
getIllustFollow Publicity
restrict (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetIllustFollow
-> Proxy m
-> (Token, Maybe Text)
-> Publicity
-> Maybe Int
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustFollow
forall k (t :: k). Proxy t
Proxy @GetIllustFollow) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Publicity
restrict Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Gets the newest illustrations.
getIllustNew ::
  MonadPixiv m =>
  -- | page
  Int ->
  m [Illust]
getIllustNew :: Int -> m [Illust]
getIllustNew (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetIllustNew
-> Proxy m -> (Token, Maybe Text) -> Maybe Int -> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetIllustNew
forall k (t :: k). Proxy t
Proxy @GetIllustNew) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Gets the metadata of a ugoira
getUgoiraMetadata ::
  MonadPixiv m =>
  -- | illust id
  Int ->
  m UgoiraMetadata
getUgoiraMetadata :: Int -> m UgoiraMetadata
getUgoiraMetadata Int
illustId = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  UgoiraMetadataWrapper
ug <- Proxy GetUgoiraMetadata
-> Proxy m -> (Token, Maybe Text) -> Int -> m UgoiraMetadataWrapper
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUgoiraMetadata
forall k (t :: k). Proxy t
Proxy @GetUgoiraMetadata) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
illustId
  UgoiraMetadata -> m UgoiraMetadata
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (UgoiraMetadata -> m UgoiraMetadata)
-> UgoiraMetadata -> m UgoiraMetadata
forall a b. (a -> b) -> a -> b
$ UgoiraMetadataWrapper -> UgoiraMetadata
coerce UgoiraMetadataWrapper
ug

-----------------------------------------------------------------------------

-- | Searches an illustration.
searchIllust ::
  MonadPixiv m =>
  -- | search target
  SearchTarget ->
  -- | word
  Text ->
  -- | includes translated tag
  Maybe Bool ->
  -- | sorting method
  Maybe SortingMethod ->
  -- | duration
  Maybe Duration ->
  -- | page
  Int ->
  m [Illust]
searchIllust :: SearchTarget
-> Text
-> Maybe Bool
-> Maybe SortingMethod
-> Maybe Duration
-> Int
-> m [Illust]
searchIllust SearchTarget
searchTarget Text
searchWord Maybe Bool
includeTranslatedTag Maybe SortingMethod
sortingMethod Maybe Duration
duration (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy SearchIllust
-> Proxy m
-> (Token, Maybe Text)
-> SearchTarget
-> Text
-> Maybe Bool
-> Maybe SortingMethod
-> Maybe Duration
-> Maybe Int
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy SearchIllust
forall k (t :: k). Proxy t
Proxy @SearchIllust) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p SearchTarget
searchTarget Text
searchWord Maybe Bool
includeTranslatedTag Maybe SortingMethod
sortingMethod Maybe Duration
duration Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- | Searches an user.
searchUser ::
  MonadPixiv m =>
  -- | word
  Text ->
  -- | page
  Int ->
  m [UserPreview]
searchUser :: Text -> Int -> m [UserPreview]
searchUser Text
searchWord (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  UserPreviews
ups <- Proxy SearchUser
-> Proxy m
-> (Token, Maybe Text)
-> Text
-> Maybe Int
-> m UserPreviews
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy SearchUser
forall k (t :: k). Proxy t
Proxy @SearchUser) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Text
searchWord Maybe Int
offset
  [UserPreview] -> m [UserPreview]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([UserPreview] -> m [UserPreview])
-> [UserPreview] -> m [UserPreview]
forall a b. (a -> b) -> a -> b
$ UserPreviews -> NextUrlLess UserPreviews
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl UserPreviews
ups

-----------------------------------------------------------------------------

-- | Gets the details of an user.
getUserDetail ::
  MonadPixiv m =>
  -- | user id
  Int ->
  m UserDetail
getUserDetail :: Int -> m UserDetail
getUserDetail Int
userId = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Proxy GetUserDetail
-> Proxy m -> (Token, Maybe Text) -> Int -> m UserDetail
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserDetail
forall k (t :: k). Proxy t
Proxy @GetUserDetail) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId

-- | Gets illustrations submitted by a specific user.
getUserIllusts ::
  MonadPixiv m =>
  -- | user id
  Int ->
  -- | illust type
  Maybe IllustType ->
  -- | page
  Int ->
  m [Illust]
getUserIllusts :: Int -> Maybe IllustType -> Int -> m [Illust]
getUserIllusts Int
userId Maybe IllustType
illustType (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetUserIllusts
-> Proxy m
-> (Token, Maybe Text)
-> Int
-> Maybe IllustType
-> Maybe Int
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserIllusts
forall k (t :: k). Proxy t
Proxy @GetUserIllusts) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId Maybe IllustType
illustType Maybe Int
offset
  [Illust] -> m [Illust]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([Illust] -> m [Illust]) -> [Illust] -> m [Illust]
forall a b. (a -> b) -> a -> b
$ Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts

-- |  Gets the following of an user.
getUserFollowing ::
  MonadPixiv m =>
  -- | user id
  Int ->
  -- | restrict
  Publicity ->
  -- | page
  Int ->
  m [UserPreview]
getUserFollowing :: Int -> Publicity -> Int -> m [UserPreview]
getUserFollowing Int
userId Publicity
restrict (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  UserPreviews
ups <- Proxy GetUserFollowing
-> Proxy m
-> (Token, Maybe Text)
-> Int
-> Publicity
-> Maybe Int
-> m UserPreviews
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserFollowing
forall k (t :: k). Proxy t
Proxy @GetUserFollowing) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId Publicity
restrict Maybe Int
offset
  [UserPreview] -> m [UserPreview]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([UserPreview] -> m [UserPreview])
-> [UserPreview] -> m [UserPreview]
forall a b. (a -> b) -> a -> b
$ UserPreviews -> NextUrlLess UserPreviews
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl UserPreviews
ups

-- | Gets the followers of an user.
getUserFollower ::
  MonadPixiv m =>
  -- | user id
  Int ->
  -- | page
  Int ->
  m [UserPreview]
getUserFollower :: Int -> Int -> m [UserPreview]
getUserFollower Int
userId (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  UserPreviews
ups <- Proxy GetUserFollower
-> Proxy m
-> (Token, Maybe Text)
-> Int
-> Maybe Int
-> m UserPreviews
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserFollower
forall k (t :: k). Proxy t
Proxy @GetUserFollower) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId Maybe Int
offset
  [UserPreview] -> m [UserPreview]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([UserPreview] -> m [UserPreview])
-> [UserPreview] -> m [UserPreview]
forall a b. (a -> b) -> a -> b
$ UserPreviews -> NextUrlLess UserPreviews
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl UserPreviews
ups

-- | Gets @mypixiv@ of an user.
getUserMypixiv ::
  MonadPixiv m =>
  -- | user id
  Int ->
  -- | page
  Int ->
  m [UserPreview]
getUserMypixiv :: Int -> Int -> m [UserPreview]
getUserMypixiv Int
userId (Int -> Int -> Maybe Int
pageToOffset Int
30 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  UserPreviews
ups <- Proxy GetUserMypixiv
-> Proxy m
-> (Token, Maybe Text)
-> Int
-> Maybe Int
-> m UserPreviews
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserMypixiv
forall k (t :: k). Proxy t
Proxy @GetUserMypixiv) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId Maybe Int
offset
  [UserPreview] -> m [UserPreview]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([UserPreview] -> m [UserPreview])
-> [UserPreview] -> m [UserPreview]
forall a b. (a -> b) -> a -> b
$ UserPreviews -> NextUrlLess UserPreviews
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl UserPreviews
ups

-- | Gets illustrations collected by a specific user.
-- Returns the a list of illustrations and result and an integer for paging.
getUserBookmarks ::
  MonadPixiv m =>
  -- | user id
  Int ->
  -- | restrict
  Publicity ->
  -- | the last illust id of this query
  Maybe Int ->
  m ([Illust], Maybe Int)
getUserBookmarks :: Int -> Publicity -> Maybe Int -> m ([Illust], Maybe Int)
getUserBookmarks Int
userId Publicity
restrict Maybe Int
maxBookmarkId = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  Illusts
illusts <- Proxy GetUserBookmarks
-> Proxy m
-> (Token, Maybe Text)
-> Int
-> Publicity
-> Maybe Int
-> m Illusts
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetUserBookmarks
forall k (t :: k). Proxy t
Proxy @GetUserBookmarks) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Int
userId Publicity
restrict Maybe Int
maxBookmarkId
  ([Illust], Maybe Int) -> m ([Illust], Maybe Int)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Illusts -> NextUrlLess Illusts
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl Illusts
illusts, Illusts -> Maybe Text
forall a. HasNextUrl a => a -> Maybe Text
getNextUrl Illusts
illusts Maybe Text -> (Text -> Maybe Int) -> Maybe Int
forall (m :: Type -> Type) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((Either String (Int, Text)
-> Getting (First Int) (Either String (Int, Text)) Int -> Maybe Int
forall s a. s -> Getting (First a) s a -> Maybe a
^? ((Int, Text) -> Const (First Int) (Int, Text))
-> Either String (Int, Text)
-> Const (First Int) (Either String (Int, Text))
forall c a b. Prism (Either c a) (Either c b) a b
_Right (((Int, Text) -> Const (First Int) (Int, Text))
 -> Either String (Int, Text)
 -> Const (First Int) (Either String (Int, Text)))
-> ((Int -> Const (First Int) Int)
    -> (Int, Text) -> Const (First Int) (Int, Text))
-> Getting (First Int) (Either String (Int, Text)) Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Const (First Int) Int)
-> (Int, Text) -> Const (First Int) (Int, Text)
forall s t a b. Field1 s t a b => Lens s t a b
_1) (Either String (Int, Text) -> Maybe Int)
-> (Text -> Either String (Int, Text)) -> Text -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String (Int, Text)
forall a. Integral a => Reader a
decimal (Text -> Either String (Int, Text))
-> (Text -> Text) -> Text -> Either String (Int, Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> Text
T.takeWhileEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'=')))

-----------------------------------------------------------------------------

-- | Gets spotlight articles
getSpotlightArticles ::
  MonadPixiv m =>
  -- | category
  Maybe Text ->
  -- | page
  Int ->
  m [SpotlightArticle]
getSpotlightArticles :: Maybe Text -> Int -> m [SpotlightArticle]
getSpotlightArticles Maybe Text
category (Int -> Int -> Maybe Int
pageToOffset Int
10 -> Maybe Int
offset) = do
  (Token, Maybe Text)
p <- m (Token, Maybe Text)
forall (m :: Type -> Type). MonadPixiv m => m (Token, Maybe Text)
getAccessTokenWithAccpetLanguage
  SpotlightArticles
articles <- Proxy GetSpotlightArticles
-> Proxy m
-> (Token, Maybe Text)
-> Maybe Text
-> Maybe Int
-> m SpotlightArticles
forall (m :: Type -> Type) api.
HasClient m api =>
Proxy api -> Proxy m -> Client m api
clientIn (Proxy GetSpotlightArticles
forall k (t :: k). Proxy t
Proxy @GetSpotlightArticles) Proxy m
forall k (t :: k). Proxy t
Proxy (Token, Maybe Text)
p Maybe Text
category Maybe Int
offset
  [SpotlightArticle] -> m [SpotlightArticle]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([SpotlightArticle] -> m [SpotlightArticle])
-> [SpotlightArticle] -> m [SpotlightArticle]
forall a b. (a -> b) -> a -> b
$ SpotlightArticles -> NextUrlLess SpotlightArticles
forall a. HasNextUrl a => a -> NextUrlLess a
unNextUrl SpotlightArticles
articles