[FEAT] Adding Visio micro-service (Jitsi)
[gargantext.git] / src / Gargantext / API / Table.hs
index 76c5b9bf5a71d5beefd1cbd0760663025af81ec2..773ab9d2a11f1886d60622e607e3ed06165e3c31 100644 (file)
@@ -24,13 +24,6 @@ Node API
 
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-{-# LANGUAGE DataKinds            #-}
-{-# LANGUAGE DeriveGeneric        #-}
-{-# LANGUAGE FlexibleContexts     #-}
-{-# LANGUAGE FlexibleInstances    #-}
-{-# LANGUAGE NoImplicitPrelude    #-}
-{-# LANGUAGE OverloadedStrings    #-}
-{-# LANGUAGE RankNTypes           #-}
 {-# LANGUAGE ScopedTypeVariables  #-}
 {-# LANGUAGE TemplateHaskell      #-}
 {-# LANGUAGE TypeOperators        #-}
@@ -43,69 +36,137 @@ import Data.Maybe
 import Data.Swagger
 import Data.Text (Text())
 import GHC.Generics (Generic)
-import Gargantext.API.Ngrams (TabType(..))
-import Gargantext.Core.Types (Offset, Limit)
-import Gargantext.Core.Utils.Prefix (unPrefix)
-import Gargantext.Database.Facet (FacetDoc , runViewDocuments, OrderBy(..),runViewAuthorsDoc)
-import Gargantext.Database.Learn (FavOrTrash(..), moreLike)
-import Gargantext.Database.TextSearch
-import Gargantext.Database.Types.Node
-import Gargantext.Database.Utils -- (Cmd, CmdM)
-import Gargantext.Prelude
 import Servant
 import Test.QuickCheck (elements)
 import Test.QuickCheck.Arbitrary (Arbitrary, arbitrary)
 
+import Gargantext.API.HashedResponse
+import Gargantext.API.Ngrams.Types (TabType(..))
+import Gargantext.API.Prelude (GargServer)
+import Gargantext.Core.Types (Offset, Limit, TableResult(..))
+import Gargantext.Core.Utils.Prefix (unPrefix, unPrefixSwagger)
+import Gargantext.Database.Action.Learn (FavOrTrash(..), moreLike)
+import Gargantext.Database.Action.Search
+import Gargantext.Database.Admin.Types.Node
+import Gargantext.Database.Prelude -- (Cmd, CmdM)
+import Gargantext.Database.Query.Facet (FacetDoc , runViewDocuments, runCountDocuments, OrderBy(..), runViewAuthorsDoc)
+import Gargantext.Prelude
+
 ------------------------------------------------------------------------
-type TableApi = Summary " Table API"
+
+type TableApi = Summary "Table API"
+              :> QueryParam "tabType" TabType
+              :> QueryParam "list" ListId
+              :> QueryParam "limit" Int
+              :> QueryParam "offset" Int
+              :> QueryParam "orderBy" OrderBy
+              :> QueryParam "query" Text
+              :> Get    '[JSON] (HashedResponse FacetTableResult)
+            :<|> Summary "Table API (POST)"
               :> ReqBody '[JSON] TableQuery
-              :> Post '[JSON] [FacetDoc]
+              :> Post    '[JSON] FacetTableResult
+            :<|> "hash" :>
+                   Summary "Hash Table"
+                :> QueryParam "tabType" TabType
+                :> Get '[JSON] Text
 
---{-
 data TableQuery = TableQuery
-  { tq_offset  :: Maybe Int
-  , tq_limit   :: Maybe Int
-  , tq_orderBy :: Maybe OrderBy
-  , tq_tabType :: Maybe TabType
-  , tq_mQuery  :: Maybe Text
+  { tq_offset  :: Int
+  , tq_limit   :: Int
+  , tq_orderBy :: OrderBy
+  , tq_view    :: TabType
+  , tq_query   :: Text
   } deriving (Generic)
 
+type FacetTableResult = TableResult FacetDoc
+
 $(deriveJSON (unPrefix "tq_") ''TableQuery)
 
 instance ToSchema TableQuery where
-  declareNamedSchema =
-    genericDeclareNamedSchema
-      defaultSchemaOptions {fieldLabelModifier = drop 3}
+  declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "tq_")
 
 instance Arbitrary TableQuery where
-  arbitrary = elements [TableQuery (Just 0) (Just 10) Nothing (Just Docs) (Just "electrodes")]
-
-
-tableApi :: NodeId -> TableQuery -> Cmd err [FacetDoc]
-tableApi cId (TableQuery o l order ft Nothing) = getTable cId ft o l order
-tableApi cId (TableQuery o l order ft (Just q)) = case ft of
-      Just Docs  -> searchInCorpus cId [q] o l order
-      Just Trash -> panic "TODO search in Trash" -- TODO searchInCorpus cId q o l order
-      _     -> panic "not implemented: search in Fav/Trash/*"
-
-getTable :: NodeId -> Maybe TabType
-         -> Maybe Offset  -> Maybe Limit
-         -> Maybe OrderBy -> Cmd err [FacetDoc]
-getTable cId ft o l order =
+  arbitrary = elements [TableQuery 0 10 DateAsc Docs "electrodes"]
+
+
+tableApi :: NodeId -> GargServer TableApi
+tableApi id' = getTableApi id'
+          :<|> postTableApi id'
+          :<|> getTableHashApi id'
+
+
+getTableApi :: NodeId
+            -> Maybe TabType
+            -> Maybe ListId
+            -> Maybe Int
+            -> Maybe Int
+            -> Maybe OrderBy
+            -> Maybe Text
+            -> Cmd err (HashedResponse FacetTableResult)
+getTableApi cId tabType _mListId mLimit mOffset mOrderBy mQuery = do
+  printDebug "[getTableApi] mQuery" mQuery
+  t <- getTable cId tabType mOffset mLimit mOrderBy mQuery
+  pure $ constructHashedResponse t
+
+postTableApi :: NodeId -> TableQuery -> Cmd err FacetTableResult
+postTableApi cId (TableQuery o l order ft "") = getTable cId (Just ft) (Just o) (Just l) (Just order) Nothing
+postTableApi cId (TableQuery o l order ft q) = case ft of
+      Docs  -> searchInCorpus' cId False [q] (Just o) (Just l) (Just order)
+      Trash -> searchInCorpus' cId True [q] (Just o) (Just l) (Just order)
+      x     -> panic $ "not implemented in tableApi " <> (cs $ show x)
+
+getTableHashApi :: NodeId -> Maybe TabType -> Cmd err Text
+getTableHashApi cId tabType = do
+  HashedResponse { hash = h } <- getTableApi cId tabType Nothing Nothing Nothing Nothing Nothing
+  pure h
+
+searchInCorpus' :: CorpusId
+                -> Bool
+                -> [Text]
+                -> Maybe Offset
+                -> Maybe Limit
+                -> Maybe OrderBy
+                -> Cmd err FacetTableResult
+searchInCorpus' cId t q o l order = do
+  docs          <- searchInCorpus cId t q o l order
+  countAllDocs  <- searchCountInCorpus cId t q
+  pure $ TableResult { tr_docs = docs, tr_count = countAllDocs }
+
+
+getTable :: NodeId
+         -> Maybe TabType
+         -> Maybe Offset
+         -> Maybe Limit
+         -> Maybe OrderBy
+         -> Maybe Text
+         -> Cmd err FacetTableResult
+getTable cId ft o l order query = do
+  docs      <- getTable' cId ft o l order query
+  docsCount <- runCountDocuments cId (ft == Just Trash) query
+  pure $ TableResult { tr_docs = docs, tr_count = docsCount }
+
+getTable' :: NodeId
+          -> Maybe TabType
+          -> Maybe Offset
+          -> Maybe Limit
+          -> Maybe OrderBy
+          -> Maybe Text
+          -> Cmd err [FacetDoc]
+getTable' cId ft o l order query =
   case ft of
-    (Just Docs)  -> runViewDocuments cId False o l order
-    (Just Trash) -> runViewDocuments cId True  o l order
+    (Just Docs)      -> runViewDocuments cId False o l order query
+    (Just Trash)     -> runViewDocuments cId True  o l order query
     (Just MoreFav)   -> moreLike cId o l order IsFav
     (Just MoreTrash) -> moreLike cId o l order IsTrash
-    _     -> panic "not implemented"
+    x     -> panic $ "not implemented in getTable: " <> (cs $ show x)
+
 
-getPairing :: ContactId -> Maybe TabType
+getPair :: ContactId -> Maybe TabType
          -> Maybe Offset  -> Maybe Limit
          -> Maybe OrderBy -> Cmd err [FacetDoc]
-getPairing cId ft o l order =
+getPair cId ft o l order =
   case ft of
     (Just Docs)  -> runViewAuthorsDoc cId False o l order
     (Just Trash) -> runViewAuthorsDoc cId True  o l order
-    _     -> panic "not implemented"
-
+    _     -> panic $ "not implemented: get Pairing" <> (cs $ show ft)