,text

   ,time

   ,transformers

   ,utf8-string

   ,mime-mail

           ,("/report/:id",run Report.handle)

           ,("/reported",run Reported.handle)

           ,("/new",run New.handle)

           ,("/edit/:id",run New.handle)

           ,("/new/:channel",run New.handle)

           ,("/browse",run Browse.handle)

           ,("/activity",run Activity.handle)

           ,("/diff/:this/:that",run Diff.handle)

           ]

  run = runHandler conf p cache ans

{-# LANGUAGE RecordWildCards #-}

{-# LANGUAGE OverloadedStrings #-}

{-# OPTIONS -fno-warn-name-shadowing -fno-warn-unused-do-bind #-}

module Text.Blaze.Extra where

import Data.Monoid

import Data.Monoid.Operator

import Prelude                     hiding ((++),head,div)

import Text.Blaze.Html5            as H hiding (map)

import Text.Blaze.Html5.Attributes as A

import Network.URI

import Text.Printf

import Data.List (intercalate)

elem !. className = elem ! class_ className

elem !# idName = elem ! A.id idName

linesToHtml :: String -> Html

linesToHtml str = forM_ (lines str) $ \line -> do toHtml line; br

htmlCommasAnd [x] = x

htmlCommasAnd [x,y] = do x; " and "; y

htmlCommasAnd (x:xs) = do x; ", "; htmlCommasAnd xs

htmlCommasAnd []  = mempty

htmlCommas = htmlIntercalate ", "

  ,outputText

  ,goHome

  ,justOrGoHome

  ,getInteger

  ,getString

  ,getPagination)

  where

import Amelie.Types

import Amelie.Types.Cache

import Control.Applicative

import Control.Concurrent.Chan    (Chan)

import Control.Monad.Reader       (runReaderT)

import Data.ByteString            (ByteString)

import Data.ByteString.UTF8       (toString)

import Data.Text.Lazy             (Text,toStrict)

import Database.PostgreSQL.Base   (withPoolConnection)

import Database.PostgreSQL.Simple (Pool)

import Safe                       (readMay)

import Text.Blaze                 (Html)

import Text.Blaze.Renderer.Text   (renderHtml)

-- | Run a controller handler.

runHandler :: Config -> Pool -> Cache -> Chan Text -> Controller () -> Snap ()

getString :: ByteString -> String -> Controller String

getString name def = do

  pid <- (>>= return . toString) <$> getParam name

  maybe (return def) return pid

-- | Get pagination data.

getPagination :: Controller Pagination

getPagination = do

  p <- getInteger "page" 1

  limit <- getInteger "limit" 35

  return Pagination { pnPage = max 1 p

                    , pnLimit = max 1 (min 100 limit)

                    , pnResults = 0

                    , pnTotal = 0

                    }

import           Data.Maybe                  (fromMaybe)

import           Data.Monoid.Operator        ((++))

import           Data.Text                   (pack)

import           Data.Text.Lazy              (Text)

import qualified Data.Text.Lazy              as T

import           Prelude                     hiding ((++))

import           Text.Blaze.Html5            as H hiding (map,nav)

import qualified Text.Blaze.Html5.Attributes as A

-- | A class prefixed with amelie-.

aClass :: AttributeValue -> Attribute

aClass name = A.class_ ("amelie-" ++ name)

          end = pnPage * pnResults

-- | Link to change navigation page based on a direction.

navDirection :: Pagination -> Integer -> Text -> Html

navDirection Pagination{..} change caption = do

module Amelie.Types.View

  (Pagination(..))

  where

-- | Pagination data.

data Pagination = Pagination {

   pnPage :: Integer

 , pnLimit :: Integer

 , pnResults :: Integer

 , pnTotal :: Integer

} deriving Show

import Prelude                hiding ((++))

import System.Directory

import System.FilePath

-- | Count public pastes.

  return $ fromMaybe 0 rows

-- | Get the latest pastes.

getLatestPastes :: Model [Paste]

getLatestPastes =

                ,"FROM public_toplevel_paste"

                ,"ORDER BY id DESC"

                ,"LIMIT 20"]

-- | Get some paginated pastes.

-- | Get a paste by its id.

getPasteById :: PasteId -> Model (Maybe Paste)

getPasteById pid =

  listToMaybe <$> query ["SELECT *"

module Amelie.Controller.Browse

  (handle)

  where

import Amelie.Model

import Amelie.Model.Channel  (getChannels)

import Amelie.Model.Language (getLanguages)

import Amelie.Model.Paste    (getSomePastes,countPublicPastes)

import Amelie.View.Browse    (page)

-- | Browse all pastes.

handle :: Controller ()

handle = do

  pn <- getPagination

               , pnTotal = total }

  chans <- model getChannels

  langs <- model getLanguages

  output $ page pn' chans langs pastes

handle :: Controller ()

handle = do

  pn <- getPagination

  total <- model countReports

  reports <- model $ getSomeReports pn

               , pnTotal = total }

  output $ page pn' reports