{-# OPTIONS_GHC -fno-warn-unused-matches #-}
{-# LANGUAGE TupleSections #-}
module Handler.User where

import qualified Data.Text as T
import           Handler.Common
import           Import
import qualified Text.Blaze.Html5 as H
import           Yesod.RssFeed
import qualified Data.Map as Map
import qualified Network.Wai.Internal as W

getUserR :: UserNameP -> Handler Html
getUserR :: UserNameP -> Handler Markup
getUserR UserNameP
uname=
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler Markup
_getUser UserNameP
uname SharedP
SharedAll FilterP
FilterAll ([Text] -> TagsP
TagsP [])

getUserSharedR :: UserNameP -> SharedP -> Handler Html
getUserSharedR :: UserNameP -> SharedP -> Handler Markup
getUserSharedR UserNameP
uname SharedP
sharedp =
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler Markup
_getUser UserNameP
uname SharedP
sharedp FilterP
FilterAll ([Text] -> TagsP
TagsP [])

getUserFilterR :: UserNameP -> FilterP -> Handler Html
getUserFilterR :: UserNameP -> FilterP -> Handler Markup
getUserFilterR UserNameP
uname FilterP
filterp =
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler Markup
_getUser UserNameP
uname SharedP
SharedAll FilterP
filterp ([Text] -> TagsP
TagsP [])

getUserTagsR :: UserNameP -> TagsP -> Handler Html
getUserTagsR :: UserNameP -> TagsP -> Handler Markup
getUserTagsR UserNameP
uname = UserNameP -> SharedP -> FilterP -> TagsP -> Handler Markup
_getUser UserNameP
uname SharedP
SharedAll FilterP
FilterAll

_getUser :: UserNameP -> SharedP -> FilterP -> TagsP -> Handler Html
_getUser :: UserNameP -> SharedP -> FilterP -> TagsP -> Handler Markup
_getUser unamep :: UserNameP
unamep@(UserNameP Text
uname) SharedP
sharedp' FilterP
filterp' (TagsP [Text]
pathtags) = do
  Maybe Text
mauthuname <- Handler (Maybe Text)
maybeAuthUsername
  (Maybe Page
limit', Maybe Page
page') <- Handler (Maybe Page, Maybe Page)
lookupPagingParams
  let limit :: Page
limit = Page -> (Page -> Page) -> Maybe Page -> Page
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Page
120 Page -> Page
forall a b. (Integral a, Num b) => a -> b
fromIntegral Maybe Page
limit'
      page :: Page
page  = Page -> (Page -> Page) -> Maybe Page -> Page
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Page
1   Page -> Page
forall a b. (Integral a, Num b) => a -> b
fromIntegral Maybe Page
page'
      isowner :: Bool
isowner = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
uname Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Text
mauthuname
      sharedp :: SharedP
sharedp = if Bool
isowner then SharedP
sharedp' else SharedP
SharedPublic
      filterp :: FilterP
filterp = case FilterP
filterp' of
        FilterSingle BmSlug
_ -> FilterP
filterp'
        FilterP
_ -> if Bool
isowner then FilterP
filterp' else FilterP
FilterAll
      isAll :: Bool
isAll = FilterP
filterp FilterP -> FilterP -> Bool
forall a. Eq a => a -> a -> Bool
== FilterP
FilterAll Bool -> Bool -> Bool
&& SharedP
sharedp SharedP -> SharedP -> Bool
forall a. Eq a => a -> a -> Bool
== SharedP
SharedAll Bool -> Bool -> Bool
&& [Text] -> Bool
forall mono. MonoFoldable mono => mono -> Bool
null [Text]
pathtags
      queryp :: Text
queryp = Text
"query" :: Text
  Maybe Text
mquery <- Text -> Handler (Maybe Text)
forall (m :: * -> *). MonadHandler m => Text -> m (Maybe Text)
lookupGetParam Text
queryp
  let mqueryp :: Maybe (Text, Text)
mqueryp = (Text -> (Text, Text)) -> Maybe Text -> Maybe (Text, Text)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text
queryp,) Maybe Text
mquery
  (Int
bcount, [(Entity Bookmark, Maybe Text)]
btmarks) <- YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
-> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)])
forall a. YesodDB App a -> HandlerFor App a
forall site a.
YesodPersist site =>
YesodDB site a -> HandlerFor site a
runDB (YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
 -> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)]))
-> YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
-> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)])
forall a b. (a -> b) -> a -> b
$ do
       Entity Key User
userId User
user <- Unique User -> ReaderT SqlBackend (HandlerFor App) (Entity User)
forall backend val (m :: * -> *).
(PersistUniqueRead backend, PersistRecordBackend val backend,
 MonadIO m) =>
Unique val -> ReaderT backend m (Entity val)
getBy404 (Text -> Unique User
UniqueUserName Text
uname)
       Bool
-> ReaderT SqlBackend (HandlerFor App) ()
-> ReaderT SqlBackend (HandlerFor App) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
isowner Bool -> Bool -> Bool
&& User -> Bool
userPrivacyLock User
user)
         (Route App -> ReaderT SqlBackend (HandlerFor App) ()
forall (m :: * -> *) url a.
(MonadHandler m, RedirectUrl (HandlerSite m) url) =>
url -> m a
redirect (Route Auth -> Route App
AuthR Route Auth
LoginR))
       Key User
-> SharedP
-> FilterP
-> [Text]
-> Maybe Text
-> Page
-> Page
-> DB (Int, [(Entity Bookmark, Maybe Text)])
bookmarksTagsQuery Key User
userId SharedP
sharedp FilterP
filterp [Text]
pathtags Maybe Text
mquery Page
limit Page
page
  Bool -> HandlerFor App () -> HandlerFor App ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
bcount Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (case FilterP
filterp of FilterSingle BmSlug
_ -> HandlerFor App ()
forall (m :: * -> *) a. MonadHandler m => m a
notFound; FilterP
_ -> () -> HandlerFor App ()
forall a. a -> HandlerFor App a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
  Maybe (Route App)
mroute <- HandlerFor App (Maybe (Route (HandlerSite (HandlerFor App))))
HandlerFor App (Maybe (Route App))
forall (m :: * -> *).
MonadHandler m =>
m (Maybe (Route (HandlerSite m)))
getCurrentRoute
  TagCloudMode
tagCloudMode <- Bool -> [Text] -> HandlerFor App TagCloudMode
forall (m :: * -> *).
MonadHandler m =>
Bool -> [Text] -> m TagCloudMode
getTagCloudMode Bool
isowner [Text]
pathtags
  YesodRequest
req <- HandlerFor App YesodRequest
forall (m :: * -> *). MonadHandler m => m YesodRequest
getRequest
  WidgetFor App () -> Handler Markup
forall site.
Yesod site =>
WidgetFor site () -> HandlerFor site Markup
defaultLayout do
    let pager :: WidgetFor App ()
pager = $(widgetFile "pager")
        search :: WidgetFor App ()
search = $(widgetFile "search")
        renderEl :: Text
renderEl = Text
"bookmarks" :: Text
        tagCloudRenderEl :: Text
tagCloudRenderEl = Text
"tagCloud" :: Text
    Route (HandlerSite (WidgetFor App)) -> Text -> WidgetFor App ()
forall (m :: * -> *).
MonadWidget m =>
Route (HandlerSite m) -> Text -> m ()
rssLink (UserNameP -> Route App
UserFeedR UserNameP
unamep) Text
"feed"
    $(widgetFile "user")
    JavascriptUrl (Route App) -> WidgetFor App ()
forall site a (m :: * -> *).
(ToWidgetBody site a, MonadWidget m, HandlerSite m ~ site) =>
a -> m ()
forall (m :: * -> *).
(MonadWidget m, HandlerSite m ~ App) =>
JavascriptUrl (Route App) -> m ()
toWidgetBody [julius|
        app.dat.bmarks = #{ toJSON $ toBookmarkFormList btmarks } || [];
        app.dat.isowner = #{ isowner };
        app.userR = "@{UserR unamep}";
        app.tagCloudMode = #{ toJSON $ tagCloudMode } || {};
    |]
    JavascriptUrl (Route App) -> WidgetFor App ()
forall site a (m :: * -> *).
(ToWidget site a, MonadWidget m, HandlerSite m ~ site) =>
a -> m ()
forall (m :: * -> *).
(MonadWidget m, HandlerSite m ~ App) =>
JavascriptUrl (Route App) -> m ()
toWidget [julius|
      setTimeout(() => {
        PS.renderBookmarks('##{rawJS renderEl}')(app.dat.bmarks)();
      }, 0);
      setTimeout(() => {
        PS.renderTagCloud('##{rawJS tagCloudRenderEl}')(app.tagCloudMode)();
      }, 0);
    |]

-- Form

postUserTagCloudR :: Handler ()
postUserTagCloudR :: HandlerFor App ()
postUserTagCloudR = do
  Key User
userId <- HandlerFor App (Key User)
HandlerFor App (AuthId (HandlerSite (HandlerFor App)))
forall (m :: * -> *).
(MonadHandler m, YesodAuth (HandlerSite m)) =>
m (AuthId (HandlerSite m))
requireAuthId
  TagCloudMode
mode <- HandlerFor App TagCloudMode
forall (m :: * -> *) a. (MonadHandler m, FromJSON a) => m a
requireCheckJsonBody
  TagCloudMode -> HandlerFor App ()
_updateTagCloudMode TagCloudMode
mode
  [(Text, Int)]
tc <- YesodDB App [(Text, Int)] -> HandlerFor App [(Text, Int)]
forall a. YesodDB App a -> HandlerFor App a
forall site a.
YesodPersist site =>
YesodDB site a -> HandlerFor site a
runDB (YesodDB App [(Text, Int)] -> HandlerFor App [(Text, Int)])
-> YesodDB App [(Text, Int)] -> HandlerFor App [(Text, Int)]
forall a b. (a -> b) -> a -> b
$ case TagCloudMode
mode of
    TagCloudModeTop Bool
_ Int
n -> Key User -> Int -> DB [(Text, Int)]
tagCountTop Key User
userId Int
n
    TagCloudModeLowerBound Bool
_ Int
n -> Key User -> Int -> DB [(Text, Int)]
tagCountLowerBound Key User
userId Int
n
    TagCloudModeRelated Bool
_ [Text]
tags ->  Key User -> [Text] -> DB [(Text, Int)]
tagCountRelated Key User
userId [Text]
tags
    TagCloudMode
TagCloudModeNone -> SqlPersistT (HandlerFor App) [(Text, Int)]
YesodDB App [(Text, Int)]
forall (m :: * -> *) a. MonadHandler m => m a
notFound
  Status -> Map Text Int -> HandlerFor App ()
forall (m :: * -> *) c a.
(MonadHandler m, ToJSON c) =>
Status -> c -> m a
sendStatusJSON Status
ok200 ([(Text, Int)] -> Map Text Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Int)]
tc :: Map.Map Text Int)

postUserTagCloudModeR :: Handler ()
postUserTagCloudModeR :: HandlerFor App ()
postUserTagCloudModeR = do
  Key User
userId <- HandlerFor App (Key User)
HandlerFor App (AuthId (HandlerSite (HandlerFor App)))
forall (m :: * -> *).
(MonadHandler m, YesodAuth (HandlerSite m)) =>
m (AuthId (HandlerSite m))
requireAuthId
  TagCloudMode
mode <- HandlerFor App TagCloudMode
forall (m :: * -> *) a. (MonadHandler m, FromJSON a) => m a
requireCheckJsonBody
  TagCloudMode -> HandlerFor App ()
_updateTagCloudMode TagCloudMode
mode

_updateTagCloudMode :: TagCloudMode -> Handler ()
_updateTagCloudMode :: TagCloudMode -> HandlerFor App ()
_updateTagCloudMode TagCloudMode
mode =
  case TagCloudMode
mode of
    TagCloudModeTop Bool
_ Int
_ -> TagCloudMode -> HandlerFor App ()
forall (m :: * -> *). MonadHandler m => TagCloudMode -> m ()
setTagCloudMode TagCloudMode
mode
    TagCloudModeLowerBound Bool
_ Int
_ -> TagCloudMode -> HandlerFor App ()
forall (m :: * -> *). MonadHandler m => TagCloudMode -> m ()
setTagCloudMode TagCloudMode
mode
    TagCloudModeRelated Bool
_ [Text]
_ -> TagCloudMode -> HandlerFor App ()
forall (m :: * -> *). MonadHandler m => TagCloudMode -> m ()
setTagCloudMode TagCloudMode
mode
    TagCloudMode
TagCloudModeNone -> HandlerFor App ()
forall (m :: * -> *) a. MonadHandler m => m a
notFound

bookmarkToRssEntry :: (Entity Bookmark, Maybe Text) -> FeedEntry Text
bookmarkToRssEntry :: (Entity Bookmark, Maybe Text) -> FeedEntry Text
bookmarkToRssEntry (Entity Key Bookmark
entryId Bookmark
entry, Maybe Text
tags) =
  FeedEntry
  { feedEntryLink :: Text
feedEntryLink = Bookmark -> Text
bookmarkHref Bookmark
entry
  , feedEntryUpdated :: UTCTime
feedEntryUpdated = Bookmark -> UTCTime
bookmarkTime Bookmark
entry
  , feedEntryTitle :: Text
feedEntryTitle = Bookmark -> Text
bookmarkDescription Bookmark
entry
  , feedEntryContent :: Markup
feedEntryContent = Text -> Markup
forall a. ToMarkup a => a -> Markup
toHtml (Bookmark -> Text
bookmarkExtended Bookmark
entry)
  , feedEntryCategories :: [EntryCategory]
feedEntryCategories = (Text -> EntryCategory) -> [Text] -> [EntryCategory]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (Maybe Text -> Maybe Text -> Text -> EntryCategory
EntryCategory Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing) ([Text] -> (Text -> [Text]) -> Maybe Text -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Text -> [Text]
forall t. Textual t => t -> [t]
words Maybe Text
tags)
  , feedEntryEnclosure :: Maybe (EntryEnclosure Text)
feedEntryEnclosure = Maybe (EntryEnclosure Text)
forall a. Maybe a
Nothing
  }

getUserFeedR :: UserNameP -> Handler RepRss
getUserFeedR :: UserNameP -> Handler RepRss
getUserFeedR UserNameP
unamep = do
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed UserNameP
unamep SharedP
SharedAll FilterP
FilterAll ([Text] -> TagsP
TagsP [])

getUserFeedSharedR :: UserNameP -> SharedP -> Handler RepRss
getUserFeedSharedR :: UserNameP -> SharedP -> Handler RepRss
getUserFeedSharedR UserNameP
uname SharedP
sharedp =
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed UserNameP
uname SharedP
sharedp FilterP
FilterAll ([Text] -> TagsP
TagsP [])

getUserFeedFilterR :: UserNameP -> FilterP -> Handler RepRss
getUserFeedFilterR :: UserNameP -> FilterP -> Handler RepRss
getUserFeedFilterR UserNameP
uname FilterP
filterp =
  UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed UserNameP
uname SharedP
SharedAll FilterP
filterp ([Text] -> TagsP
TagsP [])

getUserFeedTagsR :: UserNameP -> TagsP -> Handler RepRss
getUserFeedTagsR :: UserNameP -> TagsP -> Handler RepRss
getUserFeedTagsR UserNameP
uname = UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed UserNameP
uname SharedP
SharedAll FilterP
FilterAll

_getUserFeed :: UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed :: UserNameP -> SharedP -> FilterP -> TagsP -> Handler RepRss
_getUserFeed unamep :: UserNameP
unamep@(UserNameP Text
uname) SharedP
sharedp' FilterP
filterp' (TagsP [Text]
pathtags) = do
  Maybe Text
mauthuname <- Handler (Maybe Text)
maybeAuthUsername
  (Maybe Page
limit', Maybe Page
page') <- Handler (Maybe Page, Maybe Page)
lookupPagingParams
  let limit :: Page
limit = Page -> (Page -> Page) -> Maybe Page -> Page
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Page
120 Page -> Page
forall a b. (Integral a, Num b) => a -> b
fromIntegral Maybe Page
limit'
      page :: Page
page  = Page -> (Page -> Page) -> Maybe Page -> Page
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Page
1   Page -> Page
forall a b. (Integral a, Num b) => a -> b
fromIntegral Maybe Page
page'
      isowner :: Bool
isowner = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
uname Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Text
mauthuname
      sharedp :: SharedP
sharedp = if Bool
isowner then SharedP
sharedp' else SharedP
SharedPublic
      filterp :: FilterP
filterp = case FilterP
filterp' of
        FilterSingle BmSlug
_ -> FilterP
filterp'
        FilterP
_ -> if Bool
isowner then FilterP
filterp' else FilterP
FilterAll
      -- isAll = filterp == FilterAll && sharedp == SharedAll && null pathtags
      queryp :: Text
queryp = Text
"query" :: Text
  Maybe Text
mquery <- Text -> Handler (Maybe Text)
forall (m :: * -> *). MonadHandler m => Text -> m (Maybe Text)
lookupGetParam Text
queryp
  (Int
_, [(Entity Bookmark, Maybe Text)]
btmarks) <- YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
-> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)])
forall a. YesodDB App a -> HandlerFor App a
forall site a.
YesodPersist site =>
YesodDB site a -> HandlerFor site a
runDB (YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
 -> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)]))
-> YesodDB App (Int, [(Entity Bookmark, Maybe Text)])
-> HandlerFor App (Int, [(Entity Bookmark, Maybe Text)])
forall a b. (a -> b) -> a -> b
$ do
       Entity Key User
userId User
user <- Unique User -> ReaderT SqlBackend (HandlerFor App) (Entity User)
forall backend val (m :: * -> *).
(PersistUniqueRead backend, PersistRecordBackend val backend,
 MonadIO m) =>
Unique val -> ReaderT backend m (Entity val)
getBy404 (Text -> Unique User
UniqueUserName Text
uname)
       Bool
-> ReaderT SqlBackend (HandlerFor App) ()
-> ReaderT SqlBackend (HandlerFor App) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
isowner Bool -> Bool -> Bool
&& User -> Bool
userPrivacyLock User
user)
         (Route App -> ReaderT SqlBackend (HandlerFor App) ()
forall (m :: * -> *) url a.
(MonadHandler m, RedirectUrl (HandlerSite m) url) =>
url -> m a
redirect (Route Auth -> Route App
AuthR Route Auth
LoginR))
       Key User
-> SharedP
-> FilterP
-> [Text]
-> Maybe Text
-> Page
-> Page
-> DB (Int, [(Entity Bookmark, Maybe Text)])
bookmarksTagsQuery Key User
userId SharedP
sharedp FilterP
filterp [Text]
pathtags Maybe Text
mquery Page
limit Page
page
  let (Markup
descr :: Html) = Markup -> Markup
forall a. ToMarkup a => a -> Markup
toHtml (Markup -> Markup) -> Markup -> Markup
forall a b. (a -> b) -> a -> b
$ Text -> Markup
H.text (Text
"Bookmarks saved by " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
uname)
      entries :: [FeedEntry Text]
entries = ((Entity Bookmark, Maybe Text) -> FeedEntry Text)
-> [(Entity Bookmark, Maybe Text)] -> [FeedEntry Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (Entity Bookmark, Maybe Text) -> FeedEntry Text
bookmarkToRssEntry [(Entity Bookmark, Maybe Text)]
btmarks
  UTCTime
updated <- case [UTCTime] -> Maybe (Element [UTCTime])
forall mono.
(MonoFoldable mono, Ord (Element mono)) =>
mono -> Maybe (Element mono)
maximumMay ((FeedEntry Text -> UTCTime) -> [FeedEntry Text] -> [UTCTime]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map FeedEntry Text -> UTCTime
forall url. FeedEntry url -> UTCTime
feedEntryUpdated [FeedEntry Text]
entries) of
                Maybe (Element [UTCTime])
Nothing -> IO UTCTime -> HandlerFor App UTCTime
forall a. IO a -> HandlerFor App a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UTCTime
getCurrentTime
                Just Element [UTCTime]
m ->  UTCTime -> HandlerFor App UTCTime
forall a. a -> HandlerFor App a
forall (m :: * -> *) a. Monad m => a -> m a
return UTCTime
Element [UTCTime]
m
  (Text
feedLinkSelf, Text
feedLinkHome) <- HandlerFor App (Text, Text)
getFeedLinkSelf
  Feed Text -> Handler RepRss
forall (m :: * -> *). MonadHandler m => Feed Text -> m RepRss
rssFeedText (Feed Text -> Handler RepRss) -> Feed Text -> Handler RepRss
forall a b. (a -> b) -> a -> b
$
    Feed
    { feedTitle :: Text
feedTitle = Text
"espial " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
uname
    , feedLinkSelf :: Text
feedLinkSelf = Text
feedLinkSelf
    , feedLinkHome :: Text
feedLinkHome = Text
feedLinkHome
    , feedAuthor :: Text
feedAuthor = Text
uname
    , feedDescription :: Markup
feedDescription = Markup
descr
    , feedLanguage :: Text
feedLanguage = Text
"en"
    , feedUpdated :: UTCTime
feedUpdated = UTCTime
updated
    , feedLogo :: Maybe (Text, Text)
feedLogo = Maybe (Text, Text)
forall a. Maybe a
Nothing
    , feedEntries :: [FeedEntry Text]
feedEntries = [FeedEntry Text]
entries
    }
  where
    getFeedLinkSelf :: HandlerFor App (Text, Text)
getFeedLinkSelf = do
      YesodRequest
request <- HandlerFor App YesodRequest
forall (m :: * -> *). MonadHandler m => m YesodRequest
getRequest
      Route App -> Text
render <- HandlerFor App (Route (HandlerSite (HandlerFor App)) -> Text)
HandlerFor App (Route App -> Text)
forall (m :: * -> *).
MonadHandler m =>
m (Route (HandlerSite m) -> Text)
getUrlRender
      let rawRequest :: Request
rawRequest = YesodRequest -> Request
reqWaiRequest YesodRequest
request
          feedLinkSelf :: Text
feedLinkSelf = Route App -> Text
render Route App
HomeR Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (Int -> Text -> Text
T.drop Int
1 (ByteString -> Text
forall textual binary. Utf8 textual binary => binary -> textual
decodeUtf8 (Request -> ByteString
W.rawPathInfo Request
rawRequest ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Request -> ByteString
W.rawQueryString Request
rawRequest)))
          feedLinkHome :: Text
feedLinkHome = Route App -> Text
render (UserNameP -> Route App
UserR UserNameP
unamep)
      (Text, Text) -> HandlerFor App (Text, Text)
forall a. a -> HandlerFor App a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
feedLinkSelf, Text
feedLinkHome)