import Control.Concurrent.Chan    (Chan)

import Data.Text.Lazy             (Text)

import Database.PostgreSQL.Simple (Pool,newPool)

import System.Environment

-- | Main entry point.

main :: IO ()

main = do

  cpath:_ <- getArgs

  config <- getConfig cpath

  announces <- newAnnouncer (configAnnounce config)

  pool <- newPool (configPostgres config)

  cache <- newCache

  setUnicodeLocale "en_US"

  httpServe server (serve config pool cache announces)

 where server = addListen (ListenHttp "0.0.0.0" 10000) defaultConfig

-- | Serve the controllers.

serve :: Config -> Pool -> Cache -> Chan Text -> Snap ()

serve conf p cache ans = route routes where

           ,("/js/amelie.js", run Script.handle)

           ,("/css/",serveDirectory "wwwroot/css")

           ,("/js/",serveDirectory "wwwroot/js")

           ,("/hs/",serveDirectory "wwwroot/hs")

           ,("",run Home.handle)

           ,("/:id",run Paste.handle)

           ,("/steps/:id",run Steps.handle)

           ,("/raw/:id",run Raw.handle)

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

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

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

           ,("/browse/page/:page/offset/:offset",run Browse.handle)

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

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

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

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

           ,("/stepeval/raw",run Stepeval.handleRaw)

           ,("/stepeval",run Stepeval.handle)

           ]

  run = runHandler conf p cache ans

import Data.Time

import Network.Curl.Download

import System.Locale

import Text.Feed.Query

-- | Get commits of this project from a commit feed.

getCommits :: String -> Model [Commit]

getCommits uri = io $ do

  result <- openAsFeed uri

  case result of

countPublicPastes = do

  rows <- singleNoParams ["SELECT COUNT(*)"

                         ,"FROM public_toplevel_paste"]

  return $ fromMaybe 0 rows

-- | Get the latest pastes.

getLatestPastes :: Model [Paste]

getLatestPastes =

  queryNoParams ["SELECT *"

                ,"FROM public_toplevel_paste"

                ,"ORDER BY id DESC"

                ,"LIMIT 20"]

getSomePastes :: Pagination -> Model [Paste]

getSomePastes Pagination{..} =

  queryNoParams ["SELECT *"

                ,"FROM public_toplevel_paste"

                ,"ORDER BY id DESC"

                ,"OFFSET " ++ show (max 0 (pnPage - 1) * pnLimit)

                ,"LIMIT " ++ show pnLimit]

-- | Get a paste by its id.

getPasteById :: PasteId -> Model (Maybe Paste)

getPasteById pid =

  listToMaybe <$> query ["SELECT *"

                        ,"FROM public_paste"

  case pasteSubmitId of

    Nothing  -> createPaste langs chans paste

    Just pid -> do updatePaste pid paste

                   return $ Just pid

-- | Create a new paste (possibly editing an existing one).

createPaste :: [Language] -> [Channel] -> PasteSubmit -> Model (Maybe PasteId)

createPaste langs chans ps@PasteSubmit{..} = do

  res <- single ["INSERT INTO paste"

                ,"(title,author,content,channel,language,annotation_of)"

  query ["SELECT type,content"

        ,"FROM hint"

        ,"WHERE paste = ?"]

        (Only pid)

-- | Update an existing paste.

updatePaste :: PasteId -> PasteSubmit -> Model ()

updatePaste pid PasteSubmit{..} = do

  _ <- exec (["UPDATE paste"

             ,"SET"]

import Amelie.Types.Cache      as Key

import Amelie.View.Activity    (page)

import Control.Monad.Env       (env)

handle :: Controller ()

handle = do

  html <- cache Key.Activity $ do

    uri <- env $ configCommits . controllerStateConfig

    repourl <- env $ configRepoURL . controllerStateConfig

import Amelie.Model.Channel  (getChannels)

import Amelie.Model.Language (getLanguages)

import Amelie.Model.Paste    (getSomePastes,countPublicPastes)

import Amelie.View.Browse    (page)

handle :: Controller ()

handle = do

  pn <- getPagination

  total <- model countPublicPastes

  pastes <- model $ getSomePastes pn

import Amelie.Controller

import Amelie.Controller.Paste (withPasteKey)

import Amelie.Model

import Amelie.View.Diff        (page)

handle :: Controller ()

handle = do

  withPasteKey "this" $ \this ->

    withPasteKey "that" $ \that ->

      output $ page this that

import Amelie.Model.Language   (getLanguages)

import Amelie.Model.Paste      (getLatestPastes)

import Amelie.Types.Cache      as Key

import Amelie.View.Home        (page)

handle :: Controller ()

handle = do

  html <- cache Key.Home $ do

    pastes <- model $ getLatestPastes

    chans <- model $ getChannels

import Control.Applicative

import Data.Text.Encoding      (decodeUtf8)

import Snap.Types

handle :: Controller ()

handle = do

  chans <- model $ getChannels

  langs <- model $ getLanguages

  defChan <- fmap decodeUtf8 <$> getParam "channel"

import Safe

import Snap.Types

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

import Text.Formlet

-- | Handle the paste page.

handle :: Controller ()

handle = do

  pid <- getPasteId

  justOrGoHome pid $ \(pid :: Integer) -> do

import qualified Data.Text.IO         as T

import           Data.Text.Lazy       (fromStrict)

import           Prelude              hiding ((++))

import           Snap.Types

-- | Handle the stepeval explanation page.

handle :: Controller ()

handle = do

  conf     <- env controllerStateConfig

  contents <- io $ T.readFile $ configStepevalPrelude conf

  output $ page StepevalPage {

    seHints = hints

  , sePaste = contents

  }

-- | Handle the raw stepeval Prelude view.

handleRaw :: Controller ()

handleRaw = do

  modifyResponse $ setContentType "text/plain; charset=UTF-8"

  conf     <- env controllerStateConfig

import Text.Formlet

import Control.Applicative

import Data.Text               (unpack)

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

-- | Handle the paste page.

handle :: Controller ()

handle = do

  pid <- getPasteId

  justOrGoHome pid $ \(pid :: Integer) -> do