[API][DB] Pairing tools: get pairs and pairWith.
[gargantext.git] / src / Gargantext / API / Count.hs
index d38efcc15938f9d995f5791911f2754881ba39e2..5aa7d82b58084f4abc8e52c5df59ee95a93fdaa2 100644 (file)
@@ -11,27 +11,41 @@ Count API part of Gargantext.
 -}
 
 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-{-# LANGUAGE DataKinds                   #-}
-{-# LANGUAGE TemplateHaskell             #-}
-{-# LANGUAGE TypeOperators               #-}
-{-# LANGUAGE DeriveGeneric               #-}
-{-# LANGUAGE DeriveAnyClass              #-}
+
+{-# LANGUAGE NoImplicitPrelude  #-}
+{-# LANGUAGE DataKinds          #-}
+{-# LANGUAGE TemplateHaskell    #-}
+{-# LANGUAGE TypeOperators      #-}
+{-# LANGUAGE DeriveGeneric      #-}
+{-# LANGUAGE DeriveAnyClass     #-}
+{-# LANGUAGE OverloadedStrings  #-}
 
 module Gargantext.API.Count
       where
 
-import Gargantext.Prelude
 
+import GHC.Generics (Generic)
 import Prelude (Bounded, Enum, minBound, maxBound)
+
+import Data.Aeson hiding (Error)
+import Data.Aeson.TH (deriveJSON)
 import Data.Eq (Eq())
+import Data.Either
+import Data.List (repeat, permutations)
+import Data.Swagger
 import Data.Text (Text, pack)
+
 import Servant
-import GHC.Generics (Generic)
-import Data.Aeson hiding (Error)
 import Test.QuickCheck.Arbitrary
 import Test.QuickCheck (elements)
-import Data.List (repeat,permutations)
+-- import Control.Applicative ((<*>))
+
+import Gargantext.Prelude
+import Gargantext.Core.Utils.Prefix (unPrefix, unPrefixSwagger)
+
 -----------------------------------------------------------------------
+-- TODO-ACCESS: CanCount
+-- TODO-EVENTS: No events as this is a read only query.
 type CountAPI = Post '[JSON] Counts
 
 -----------------------------------------------------------------------
@@ -47,14 +61,15 @@ instance ToJSON   Scraper
 instance Arbitrary Scraper where
     arbitrary = elements scrapers
 
------------------------------------------------------------------------
------------------------------------------------------------------------
+instance ToSchema Scraper
 
+-----------------------------------------------------------------------
 data QueryBool = QueryBool Text
         deriving (Eq, Show, Generic)
 
 queries :: [QueryBool]
 queries =  [QueryBool (pack "(X OR X') AND (Y OR Y') NOT (Z OR Z')")]
+--queries =  [QueryBool (pack "(X + X') * (Y + Y') - (Z + Z')")]
 
 instance Arbitrary QueryBool where
     arbitrary = elements queries
@@ -62,7 +77,8 @@ instance Arbitrary QueryBool where
 instance FromJSON QueryBool
 instance ToJSON   QueryBool
 
-
+instance ToSchema QueryBool
+-----------------------------------------------------------------------
 
 data Query = Query { query_query :: QueryBool
                    , query_name  :: Maybe [Scraper]
@@ -70,30 +86,32 @@ data Query = Query { query_query :: QueryBool
                    deriving (Eq, Show, Generic)
 instance FromJSON Query
 instance ToJSON   Query
+
 instance Arbitrary Query where
     arbitrary = elements [ Query q (Just n) 
                          | q <- queries
                          , n <- take 10 $ permutations scrapers
                          ]
 
------------------------------------------------------------------------
------------------------------------------------------------------------
+instance ToSchema Query where
+  declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "query_")
 
+-----------------------------------------------------------------------
+type Code = Integer
 type Error  = Text
 type Errors = [Error]
 
-data Message = Message Integer Errors
+-----------------------------------------------------------------------
+data Message = Message Code Errors
         deriving (Eq, Show, Generic)
 
-toMessage :: [(Integer, [Text])] -> [Message]
-toMessage = map (\(c,es) -> Message c es)
+toMessage :: [(Code, Errors)] -> [Message]
+toMessage = map (\(c,err) -> Message c err)
 
 messages :: [Message]
 messages =  toMessage $ [ (400, ["Ill formed query             "])
                         , (300, ["API connexion error          "])
                         , (300, ["Internal Gargantext Error    "])
-                        , (300, ["Connexion to Gargantext Error"])
-                        , (300, ["Token has expired            "])
                         ] <> take 10 ( repeat (200, [""]))
 
 instance Arbitrary Message where
@@ -102,35 +120,37 @@ instance Arbitrary Message where
 instance FromJSON Message
 instance ToJSON   Message
 
+instance ToSchema Message
 -----------------------------------------------------------------------
------------------------------------------------------------------------
-data Counts = Counts [Count]
-                   deriving (Eq, Show, Generic)
+data Counts = Counts { results :: [Either Message Count]
+                     } deriving (Eq, Show, Generic)
+
 
 instance FromJSON Counts
 instance ToJSON   Counts
 
+instance Arbitrary Counts where
+    arbitrary = elements [Counts [ Right (Count Pubmed (Just 20 ))
+                                 , Right (Count IsTex  (Just 150))
+                                 , Right (Count Hal    (Just 150))
+                                 ]
+                         ]
+
+instance ToSchema Counts
+
+-----------------------------------------------------------------------
 data Count = Count { count_name    :: Scraper
                    , count_count   :: Maybe Int
-                   , count_message :: Maybe Message
                    }
                    deriving (Eq, Show, Generic)
 
-instance FromJSON Count
-instance ToJSON   Count
+$(deriveJSON (unPrefix "count_") ''Count)
 
-instance Arbitrary Counts where
-    arbitrary = elements $ select
-                         $ map Counts 
-                         $ map (\xs -> zipWith (\s (c,m) -> Count s c m) scrapers xs) 
-                         $ chunkAlong (length scrapers) 1 $  (map filter' countOrErrors)
-        where
-            select xs = (take 10 xs) <> (take 10 $ drop 100 xs)
-            countOrErrors = [ (c,e) | c <- [500..1000], e <- reverse messages]
-            filter' (c,e) = case e of
-                              Message 200 _ -> (Just c , Nothing     )
-                              message       -> (Nothing, Just message)
+instance ToSchema Count where
+  declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "count_")
+--instance Arbitrary Count where
+--    arbitrary = Count <$> arbitrary <*> arbitrary <*> arbitrary
 
 -----------------------------------------------------------------------
-count :: Query -> Handler Counts
+count :: Monad m => Query -> m Counts
 count _ = undefined