src/Gargantext/API/Count.hs

   1 {-|
   2 Module      : Gargantext.API.Count
   3 Description : Server API
   4 Copyright   : (c) CNRS, 2017-Present
   5 License     : AGPL + CECILL v3
   6 Maintainer  : team@gargantext.org
   7 Stability   : experimental
   8 Portability : POSIX
   9
  10 Count API part of Gargantext.
  11 -}
  12
  13 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
  14
  15
  16 {-# LANGUAGE NoImplicitPrelude  #-}
  17 {-# LANGUAGE DataKinds          #-}
  18 {-# LANGUAGE TemplateHaskell    #-}
  19 {-# LANGUAGE TypeOperators      #-}
  20 {-# LANGUAGE DeriveGeneric      #-}
  21 {-# LANGUAGE DeriveAnyClass     #-}
  22 {-# LANGUAGE OverloadedStrings  #-}
  23
  24 module Gargantext.API.Count
  25       where
  26
  27
  28 import GHC.Generics (Generic)
  29 import Prelude (Bounded, Enum, minBound, maxBound)
  30
  31 import Data.Aeson hiding (Error)
  32 import Data.Aeson.TH (deriveJSON)
  33 import Data.Eq (Eq())
  34 import Data.Either
  35 import Data.List (repeat, permutations)
  36 import Data.Swagger
  37 import Data.Text (Text, pack)
  38
  39 import Servant
  40 import Test.QuickCheck.Arbitrary
  41 import Test.QuickCheck (elements)
  42 -- import Control.Applicative ((<*>))
  43
  44 import Gargantext.Prelude
  45 import Gargantext.Core.Utils.Prefix (unPrefix)
  46
  47 -----------------------------------------------------------------------
  48 type CountAPI = Post '[JSON] Counts
  49
  50 -----------------------------------------------------------------------
  51 data Scraper = Pubmed | Hal | IsTex | Isidore
  52   deriving (Eq, Show, Generic, Enum, Bounded)
  53
  54 scrapers :: [Scraper]
  55 scrapers = [minBound..maxBound]
  56
  57 instance FromJSON Scraper
  58 instance ToJSON   Scraper
  59
  60 instance Arbitrary Scraper where
  61     arbitrary = elements scrapers
  62
  63 instance ToSchema Scraper
  64
  65 -----------------------------------------------------------------------
  66 data QueryBool = QueryBool Text
  67         deriving (Eq, Show, Generic)
  68
  69 queries :: [QueryBool]
  70 queries =  [QueryBool (pack "(X OR X') AND (Y OR Y') NOT (Z OR Z')")]
  71
  72 instance Arbitrary QueryBool where
  73     arbitrary = elements queries
  74
  75 instance FromJSON QueryBool
  76 instance ToJSON   QueryBool
  77
  78 instance ToSchema QueryBool
  79 -----------------------------------------------------------------------
  80
  81 data Query = Query { query_query :: QueryBool
  82                    , query_name  :: Maybe [Scraper]
  83                    }
  84                    deriving (Eq, Show, Generic)
  85 instance FromJSON Query
  86 instance ToJSON   Query
  87
  88 instance Arbitrary Query where
  89     arbitrary = elements [ Query q (Just n)
  90                          | q <- queries
  91                          , n <- take 10 $ permutations scrapers
  92                          ]
  93
  94 instance ToSchema Query
  95 -----------------------------------------------------------------------
  96 type Code = Integer
  97 type Error  = Text
  98 type Errors = [Error]
  99
 100 -----------------------------------------------------------------------
 101 data Message = Message Code Errors
 102         deriving (Eq, Show, Generic)
 103
 104 toMessage :: [(Code, Errors)] -> [Message]
 105 toMessage = map (\(c,err) -> Message c err)
 106
 107 messages :: [Message]
 108 messages =  toMessage $ [ (400, ["Ill formed query             "])
 109                         , (300, ["API connexion error          "])
 110                         , (300, ["Internal Gargantext Error    "])
 111                         ] <> take 10 ( repeat (200, [""]))
 112
 113 instance Arbitrary Message where
 114     arbitrary = elements messages
 115
 116 instance FromJSON Message
 117 instance ToJSON   Message
 118
 119 instance ToSchema Message
 120 -----------------------------------------------------------------------
 121 data Counts = Counts { results :: [Either Message Count]
 122                      } deriving (Eq, Show, Generic)
 123
 124
 125 instance FromJSON Counts
 126 instance ToJSON   Counts
 127
 128 instance Arbitrary Counts where
 129     arbitrary = elements [Counts [ Right (Count Pubmed (Just 20 ))
 130                                  , Right (Count IsTex  (Just 150))
 131                                  , Right (Count Hal    (Just 150))
 132                                  ]
 133                          ]
 134
 135 instance ToSchema Counts
 136
 137 -----------------------------------------------------------------------
 138 data Count = Count { count_name    :: Scraper
 139                    , count_count   :: Maybe Int
 140                    }
 141                    deriving (Eq, Show, Generic)
 142
 143 $(deriveJSON (unPrefix "count_") ''Count)
 144
 145 instance ToSchema Count
 146 --instance Arbitrary Count where
 147 --    arbitrary = Count <$> arbitrary <*> arbitrary <*> arbitrary
 148
 149 -----------------------------------------------------------------------
 150 count :: Query -> Handler Counts
 151 count _ = undefined