src/Gargantext/Database/Types/Node.hs

   1 {-|
   2 Module      : Gargantext.Database.Types.Nodes
   3 Description : Main Types of Nodes in Database
   4 Copyright   : (c) CNRS, 2017-Present
   5 License     : AGPL + CECILL v3
   6 Maintainer  : team@gargantext.org
   7 Stability   : experimental
   8 Portability : POSIX
   9
  10 -}
  11
  12 {-# OPTIONS_GHC -fno-warn-orphans #-}
  13
  14 {-# LANGUAGE BangPatterns               #-}
  15 {-# LANGUAGE DeriveGeneric              #-}
  16 {-# LANGUAGE FlexibleInstances          #-}
  17 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
  18 {-# LANGUAGE NoImplicitPrelude          #-}
  19 {-# LANGUAGE OverloadedStrings          #-}
  20 {-# LANGUAGE TemplateHaskell            #-}
  21 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
  22
  23 -- {-# LANGUAGE DuplicateRecordFields #-}
  24
  25 module Gargantext.Database.Types.Node
  26   where
  27
  28 import Prelude (Enum, Bounded, minBound, maxBound)
  29
  30 import GHC.Generics (Generic)
  31
  32 import           Control.Lens hiding (elements, (&))
  33 import           Control.Applicative ((<*>))
  34 import           Control.Monad (mzero)
  35
  36 import           Data.Aeson
  37 import           Data.Aeson.Types (emptyObject)
  38 import           Data.Aeson (Object, toJSON)
  39 import           Data.Aeson.TH (deriveJSON)
  40 import           Data.ByteString.Lazy (ByteString)
  41 import           Data.Either
  42 import           Data.Eq (Eq)
  43 import           Data.Monoid (mempty)
  44 import           Data.Text (Text, unpack)
  45 import           Data.Time (UTCTime)
  46 import           Data.Swagger
  47
  48 import           Text.Read (read)
  49 import           Text.Show (Show())
  50
  51 import Database.PostgreSQL.Simple.ToField (ToField, toField, toJSONField)
  52 import Database.PostgreSQL.Simple.FromField (FromField, fromField)
  53 import           Servant
  54
  55 import           Test.QuickCheck.Arbitrary
  56 import           Test.QuickCheck (elements)
  57 import           Test.QuickCheck.Instances.Time ()
  58 import           Test.QuickCheck.Instances.Text ()
  59
  60 import           Gargantext.Prelude
  61 import           Gargantext.Core.Utils.Prefix (unPrefix, unPrefixSwagger)
  62 import           Gargantext.Viz.Phylo (Phylo)
  63 --import Gargantext.Database.Utils
  64 ------------------------------------------------------------------------
  65
  66 newtype NodeId = NodeId Int
  67   deriving (Show, Read, Generic, Num, Eq, Ord, Enum, ToJSONKey, FromJSONKey, ToJSON, FromJSON)
  68
  69 instance ToField NodeId where
  70   toField (NodeId n) = toField n
  71
  72 instance FromField NodeId where
  73   fromField field mdata = do
  74     n <- fromField field mdata
  75     if (n :: Int) > 0
  76        then return $ NodeId n
  77        else mzero
  78
  79 instance ToSchema NodeId
  80
  81
  82 type NodeTypeId   = Int
  83 type NodeName     = Text
  84 type TSVector     = Text
  85
  86 ------------------------------------------------------------------------
  87 data NodePoly id        typename userId
  88               parentId  name     date
  89               hyperdata  = Node { _node_id        :: id
  90                                 , _node_typename  :: typename
  91
  92                                 , _node_userId    :: userId
  93                                 , _node_parentId  :: parentId
  94
  95                                 , _node_name      :: name
  96                                 , _node_date      :: date
  97
  98                                 , _node_hyperdata :: hyperdata
  99                                 } deriving (Show, Generic)
 100 $(deriveJSON (unPrefix "_node_") ''NodePoly)
 101 $(makeLenses ''NodePoly)
 102
 103 -- | NodePoly indicates that Node has a Polymorphism Type
 104 type Node json   = NodePoly NodeId NodeTypeId UserId (Maybe ParentId) NodeName UTCTime json
 105
 106
 107 ------------------------------------------------------------------------
 108
 109
 110 instance FromHttpApiData NodeId where
 111   parseUrlPiece n = pure $ NodeId $ (read . cs) n
 112
 113 instance ToParamSchema NodeId
 114 instance Arbitrary NodeId where
 115   arbitrary = NodeId <$> arbitrary
 116
 117 type ParentId = NodeId
 118 type CorpusId = NodeId
 119 type ListId   = NodeId
 120 type DocumentId = NodeId
 121 type DocId      = NodeId
 122 type RootId   = NodeId
 123 type MasterCorpusId = CorpusId
 124 type UserCorpusId   = CorpusId
 125
 126 type GraphId  = NodeId
 127 type PhyloId  = NodeId
 128 type AnnuaireId = NodeId
 129 type ContactId  = NodeId
 130
 131 type UserId   = Int
 132 type MasterUserId = UserId
 133
 134 id2int :: NodeId -> Int
 135 id2int (NodeId n) = n
 136
 137 ------------------------------------------------------------------------
 138 data Status  = Status { status_failed    :: !Int
 139                       , status_succeeded :: !Int
 140                       , status_remaining :: !Int
 141                       } deriving (Show, Generic)
 142 $(deriveJSON (unPrefix "status_") ''Status)
 143
 144 instance Arbitrary Status where
 145   arbitrary = Status <$> arbitrary <*> arbitrary <*> arbitrary
 146
 147 ------------------------------------------------------------------------
 148 data StatusV3  = StatusV3 { statusV3_error  :: !(Maybe Text)
 149                           , statusV3_action :: !(Maybe Text)
 150                       } deriving (Show, Generic)
 151 $(deriveJSON (unPrefix "statusV3_") ''StatusV3)
 152 ------------------------------------------------------------------------
 153
 154 -- Only Hyperdata types should be member of this type class.
 155
 156 ------------------------------------------------------------------------
 157 data HyperdataDocumentV3 = HyperdataDocumentV3 { hyperdataDocumentV3_publication_day    :: !(Maybe Int)
 158                                                , hyperdataDocumentV3_language_iso2      :: !(Maybe Text)
 159                                                , hyperdataDocumentV3_publication_second :: !(Maybe Int)
 160                                                , hyperdataDocumentV3_publication_minute :: !(Maybe Int)
 161                                                , hyperdataDocumentV3_publication_month  :: !(Maybe Int)
 162                                                , hyperdataDocumentV3_publication_hour   :: !(Maybe Int)
 163                                                , hyperdataDocumentV3_error              :: !(Maybe Text)
 164                                                , hyperdataDocumentV3_language_iso3      :: !(Maybe Text)
 165                                                , hyperdataDocumentV3_authors            :: !(Maybe Text)
 166                                                , hyperdataDocumentV3_publication_year   :: !(Maybe Int)
 167                                                , hyperdataDocumentV3_publication_date   :: !(Maybe Text)
 168                                                , hyperdataDocumentV3_language_name      :: !(Maybe Text)
 169                                                , hyperdataDocumentV3_statuses           :: !(Maybe [StatusV3])
 170                                                , hyperdataDocumentV3_realdate_full_     :: !(Maybe Text)
 171                                                , hyperdataDocumentV3_source             :: !(Maybe Text)
 172                                                , hyperdataDocumentV3_abstract           :: !(Maybe Text)
 173                                                , hyperdataDocumentV3_title              :: !(Maybe Text)
 174                                                } deriving (Show, Generic)
 175 $(deriveJSON (unPrefix "hyperdataDocumentV3_") ''HyperdataDocumentV3)
 176
 177 class Hyperdata a
 178 instance Hyperdata HyperdataDocumentV3
 179
 180 ------------------------------------------------------------------------
 181 data HyperdataDocument = HyperdataDocument { _hyperdataDocument_bdd                :: !(Maybe Text)
 182                                            , _hyperdataDocument_doi                :: !(Maybe Text)
 183                                            , _hyperdataDocument_url                :: !(Maybe Text)
 184                                            , _hyperdataDocument_uniqId             :: !(Maybe Text)
 185                                            , _hyperdataDocument_uniqIdBdd          :: !(Maybe Text)
 186                                            , _hyperdataDocument_page               :: !(Maybe Int)
 187                                            , _hyperdataDocument_title              :: !(Maybe Text)
 188                                            , _hyperdataDocument_authors            :: !(Maybe Text)
 189                                            , _hyperdataDocument_institutes         :: !(Maybe Text)
 190                                            , _hyperdataDocument_source             :: !(Maybe Text)
 191                                            , _hyperdataDocument_abstract           :: !(Maybe Text)
 192                                            , _hyperdataDocument_publication_date   :: !(Maybe Text)
 193                                            , _hyperdataDocument_publication_year   :: !(Maybe Int)
 194                                            , _hyperdataDocument_publication_month  :: !(Maybe Int)
 195                                            , _hyperdataDocument_publication_day    :: !(Maybe Int)
 196                                            , _hyperdataDocument_publication_hour   :: !(Maybe Int)
 197                                            , _hyperdataDocument_publication_minute :: !(Maybe Int)
 198                                            , _hyperdataDocument_publication_second :: !(Maybe Int)
 199                                            , _hyperdataDocument_language_iso2      :: !(Maybe Text)
 200                                            } deriving (Show, Generic)
 201
 202 $(deriveJSON (unPrefix "_hyperdataDocument_") ''HyperdataDocument)
 203 $(makeLenses ''HyperdataDocument)
 204
 205 class ToHyperdataDocument a where
 206   toHyperdataDocument :: a -> HyperdataDocument
 207
 208 instance ToHyperdataDocument HyperdataDocument
 209   where
 210     toHyperdataDocument = identity
 211
 212 instance Eq HyperdataDocument where
 213   (==) h1 h2 = (==) (_hyperdataDocument_uniqId h1) (_hyperdataDocument_uniqId h2)
 214
 215 instance Ord HyperdataDocument where
 216   compare h1 h2 = compare (_hyperdataDocument_publication_date h1) (_hyperdataDocument_publication_date h2)
 217
 218 instance Hyperdata HyperdataDocument
 219
 220 instance ToField HyperdataDocument where
 221   toField = toJSONField
 222
 223 instance Arbitrary HyperdataDocument where
 224     arbitrary = elements arbitraryHyperdataDocuments
 225
 226 arbitraryHyperdataDocuments :: [HyperdataDocument]
 227 arbitraryHyperdataDocuments =
 228   map toHyperdataDocument' ([ ("AI is big but less than crypto", "Troll System journal")
 229                             , ("Crypto is big but less than AI", "System Troll review" )
 230                             , ("Science is magic"              , "Closed Source review")
 231                             , ("Open science for all"          , "No Time"             )
 232                             , ("Closed science for me"         , "No Space"            )
 233                             ] :: [(Text, Text)])
 234   where
 235     toHyperdataDocument' (t1,t2) =
 236       HyperdataDocument Nothing Nothing Nothing Nothing Nothing Nothing (Just t1)
 237                       Nothing Nothing (Just t2) Nothing Nothing Nothing Nothing Nothing
 238                       Nothing Nothing Nothing   Nothing
 239
 240 ------------------------------------------------------------------------
 241 data LanguageNodes = LanguageNodes { languageNodes___unknown__ :: [Int]}
 242     deriving (Show, Generic)
 243 $(deriveJSON (unPrefix "languageNodes_") ''LanguageNodes)
 244
 245 ------------------------------------------------------------------------
 246 -- level: debug | dev  (fatal = critical)
 247 data EventLevel = CRITICAL | FATAL | ERROR | WARNING | INFO | DEBUG
 248   deriving (Show, Generic, Enum, Bounded)
 249
 250 instance FromJSON EventLevel
 251 instance ToJSON EventLevel
 252
 253 instance Arbitrary EventLevel where
 254   arbitrary = elements [minBound..maxBound]
 255
 256 instance ToSchema EventLevel where
 257   declareNamedSchema proxy = genericDeclareNamedSchema defaultSchemaOptions proxy
 258
 259 ------------------------------------------------------------------------
 260
 261 data Event = Event { event_level   :: !EventLevel
 262                    , event_message :: !Text
 263                    , event_date    :: !UTCTime
 264             } deriving (Show, Generic)
 265 $(deriveJSON (unPrefix "event_") ''Event)
 266
 267 instance Arbitrary Event where
 268   arbitrary = Event <$> arbitrary <*> arbitrary <*> arbitrary
 269
 270 instance ToSchema Event where
 271   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "event_")
 272
 273 ------------------------------------------------------------------------
 274
 275 data Resource = Resource { resource_path    :: !(Maybe Text)
 276                          , resource_scraper :: !(Maybe Text)
 277                          , resource_query   :: !(Maybe Text)
 278                          , resource_events  :: !([Event])
 279                          , resource_status  :: !Status
 280                          , resource_date    :: !UTCTime
 281                          } deriving (Show, Generic)
 282 $(deriveJSON (unPrefix "resource_") ''Resource)
 283
 284 instance Arbitrary Resource where
 285     arbitrary = Resource <$> arbitrary
 286                          <*> arbitrary
 287                          <*> arbitrary
 288                          <*> arbitrary
 289                          <*> arbitrary
 290                          <*> arbitrary
 291
 292 instance ToSchema Resource where
 293   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "resource_")
 294
 295 ------------------------------------------------------------------------
 296 data HyperdataUser = HyperdataUser { hyperdataUser_language       :: Maybe Text
 297                                        } deriving (Show, Generic)
 298 $(deriveJSON (unPrefix "hyperdataUser_") ''HyperdataUser)
 299
 300 instance Hyperdata HyperdataUser
 301 ------------------------------------------------------------------------
 302 data HyperdataFolder = HyperdataFolder { hyperdataFolder_desc    :: Maybe Text
 303                                        } deriving (Show, Generic)
 304 $(deriveJSON (unPrefix "hyperdataFolder_") ''HyperdataFolder)
 305
 306 instance Hyperdata HyperdataFolder
 307 ------------------------------------------------------------------------
 308 data HyperdataCorpus = HyperdataCorpus { hyperdataCorpus_title        :: !(Maybe Text)
 309                                        , hyperdataCorpus_desc         :: !(Maybe Text)
 310                                        , hyperdataCorpus_query        :: !(Maybe Text)
 311                                        , hyperdataCorpus_authors      :: !(Maybe Text)
 312                                        , hyperdataCorpus_resources    :: !(Maybe [Resource])
 313                                        } deriving (Show, Generic)
 314 $(deriveJSON (unPrefix "hyperdataCorpus_") ''HyperdataCorpus)
 315
 316 instance Hyperdata HyperdataCorpus
 317
 318 corpusExample :: ByteString
 319 corpusExample = "" -- TODO
 320
 321 defaultCorpus :: HyperdataCorpus
 322 defaultCorpus = (HyperdataCorpus (Just "Title") (Just "Descr") (Just "Bool query") (Just "Authors") Nothing)
 323
 324 hyperdataCorpus :: HyperdataCorpus
 325 hyperdataCorpus = case decode corpusExample of
 326   Just hp -> hp
 327   Nothing -> defaultCorpus
 328
 329 instance Arbitrary HyperdataCorpus where
 330     arbitrary = pure hyperdataCorpus -- TODO
 331
 332 ------------------------------------------------------------------------
 333
 334 data HyperdataList = HyperdataList {hd_list         :: !(Maybe Text)
 335                                            } deriving (Show, Generic)
 336 $(deriveJSON (unPrefix "hd_") ''HyperdataList)
 337
 338 instance Hyperdata HyperdataList
 339
 340 ------------------------------------------------------------------------
 341 data HyperdataAnnuaire = HyperdataAnnuaire { hyperdataAnnuaire_title        :: !(Maybe Text)
 342                                            , hyperdataAnnuaire_desc         :: !(Maybe Text)
 343                                            } deriving (Show, Generic)
 344 $(deriveJSON (unPrefix "hyperdataAnnuaire_") ''HyperdataAnnuaire)
 345
 346 instance Hyperdata HyperdataAnnuaire
 347
 348 hyperdataAnnuaire :: HyperdataAnnuaire
 349 hyperdataAnnuaire = HyperdataAnnuaire (Just "Annuaire Title") (Just "Annuaire Description")
 350
 351 instance Arbitrary HyperdataAnnuaire where
 352     arbitrary = pure hyperdataAnnuaire -- TODO
 353
 354 ------------------------------------------------------------------------
 355 newtype HyperdataAny = HyperdataAny Object
 356   deriving (Show, Generic, ToJSON, FromJSON)
 357
 358 instance Hyperdata HyperdataAny
 359
 360 instance Arbitrary HyperdataAny where
 361     arbitrary = pure $ HyperdataAny mempty -- TODO produce arbitrary objects
 362 ------------------------------------------------------------------------
 363
 364 {-
 365 instance Arbitrary HyperdataList' where
 366   arbitrary = elements [HyperdataList' (Just "from list A")]
 367 -}
 368
 369                       ----
 370 data HyperdataListModel = HyperdataListModel { _hlm_params  :: !(Int, Int)
 371                                              , _hlm_path    :: !Text
 372                                              , _hlm_score   :: !(Maybe Double)
 373                                    } deriving (Show, Generic)
 374
 375 instance Hyperdata HyperdataListModel
 376 instance Arbitrary HyperdataListModel where
 377   arbitrary = elements [HyperdataListModel (100,100) "models/example.model" Nothing]
 378
 379 $(deriveJSON (unPrefix "_hlm_") ''HyperdataListModel)
 380 $(makeLenses ''HyperdataListModel)
 381
 382 ------------------------------------------------------------------------
 383 data HyperdataScore = HyperdataScore { hyperdataScore_preferences   :: !(Maybe Text)
 384                                    } deriving (Show, Generic)
 385 $(deriveJSON (unPrefix "hyperdataScore_") ''HyperdataScore)
 386
 387 instance Hyperdata HyperdataScore
 388
 389 ------------------------------------------------------------------------
 390
 391 data HyperdataResource = HyperdataResource { hyperdataResource_preferences   :: !(Maybe Text)
 392                                    } deriving (Show, Generic)
 393 $(deriveJSON (unPrefix "hyperdataResource_") ''HyperdataResource)
 394
 395 instance Hyperdata HyperdataResource
 396
 397 ------------------------------------------------------------------------
 398 data HyperdataDashboard = HyperdataDashboard { hyperdataDashboard_preferences   :: !(Maybe Text)
 399                                    } deriving (Show, Generic)
 400 $(deriveJSON (unPrefix "hyperdataDashboard_") ''HyperdataDashboard)
 401
 402 instance Hyperdata HyperdataDashboard
 403
 404 ------------------------------------------------------------------------
 405
 406 -- TODO add the Graph Structure here
 407 data HyperdataPhylo = HyperdataPhylo { hyperdataPhylo_preferences   :: !(Maybe Text)
 408                                      , hyperdataPhylo_data          :: !(Maybe Phylo)
 409                                    } deriving (Show, Generic)
 410 $(deriveJSON (unPrefix "hyperdataPhylo_") ''HyperdataPhylo)
 411
 412 instance Hyperdata HyperdataPhylo
 413
 414 ------------------------------------------------------------------------
 415 -- | TODO FEATURE: Notebook saved in the node
 416 data HyperdataNotebook = HyperdataNotebook { hyperdataNotebook_preferences   :: !(Maybe Text)
 417                                    } deriving (Show, Generic)
 418 $(deriveJSON (unPrefix "hyperdataNotebook_") ''HyperdataNotebook)
 419
 420 instance Hyperdata HyperdataNotebook
 421
 422
 423 -- | TODO CLEAN
 424 data HyperData = HyperdataTexts { hd_preferences :: Maybe Text }
 425                | HyperdataList' { hd_preferences :: Maybe Text}
 426   deriving (Show, Generic)
 427
 428 $(deriveJSON (unPrefix "hd_") ''HyperData)
 429
 430 instance Hyperdata HyperData
 431
 432
 433
 434 ------------------------------------------------------------------------
 435 -- | Then a Node can be either a Folder or a Corpus or a Document
 436 data NodeType = NodeUser
 437               | NodeFolderPrivate
 438               | NodeFolderShared | NodeTeam
 439               | NodeFolderPublic
 440               | NodeFolder
 441
 442               | NodeCorpus     | NodeCorpusV3 | NodeTexts | NodeDocument
 443               | NodeAnnuaire   | NodeContact
 444               | NodeGraph      | NodePhylo
 445               | NodeDashboard  | NodeChart    | NodeNoteBook
 446               | NodeList       | NodeListModel
 447               | NodeListCooc
 448   deriving (Show, Read, Eq, Generic, Bounded, Enum)
 449
 450
 451 {-
 452               -- | Metrics
 453               -- | NodeOccurrences
 454               -- | Classification
 455 -}
 456
 457 allNodeTypes :: [NodeType]
 458 allNodeTypes = [minBound ..]
 459
 460 instance FromJSON NodeType
 461 instance ToJSON NodeType
 462
 463 instance FromHttpApiData NodeType
 464   where
 465       parseUrlPiece = Right . read . unpack
 466
 467 instance ToParamSchema NodeType
 468 instance ToSchema      NodeType
 469
 470
 471 data NodePolySearch id        typename userId
 472               parentId  name     date
 473               hyperdata search = NodeSearch { _ns_id        :: id
 474                                       , _ns_typename  :: typename
 475                                       , _ns_userId    :: userId
 476                                                                 --   , nodeUniqId    :: shaId
 477                                       , _ns_parentId  :: parentId
 478                                       , _ns_name      :: name
 479                                       , _ns_date      :: date
 480
 481                                       , _ns_hyperdata :: hyperdata
 482                                       , _ns_search    :: search
 483                                       } deriving (Show, Generic)
 484 $(deriveJSON (unPrefix "_ns_") ''NodePolySearch)
 485 $(makeLenses ''NodePolySearch)
 486
 487 type NodeSearch json   = NodePolySearch NodeId NodeTypeId UserId (Maybe ParentId) NodeName UTCTime json (Maybe TSVector)
 488 ------------------------------------------------------------------------
 489
 490
 491 instance (Arbitrary hyperdata
 492          ,Arbitrary nodeId
 493          ,Arbitrary nodeTypeId
 494          ,Arbitrary userId
 495          ,Arbitrary nodeParentId
 496          ) => Arbitrary (NodePoly nodeId nodeTypeId userId nodeParentId
 497                                   NodeName UTCTime hyperdata) where
 498     --arbitrary = Node 1 1 (Just 1) 1 "name" (jour 2018 01 01) (arbitrary) (Just "")
 499     arbitrary = Node <$> arbitrary <*> arbitrary <*> arbitrary
 500                      <*> arbitrary <*> arbitrary <*> arbitrary
 501                      <*> arbitrary
 502
 503 instance (Arbitrary hyperdata
 504          ,Arbitrary nodeId
 505          ,Arbitrary nodeTypeId
 506          ,Arbitrary userId
 507          ,Arbitrary nodeParentId
 508          ) => Arbitrary (NodePolySearch nodeId nodeTypeId userId nodeParentId
 509                                   NodeName UTCTime hyperdata (Maybe TSVector)) where
 510     --arbitrary = Node 1 1 (Just 1) 1 "name" (jour 2018 01 01) (arbitrary) (Just "")
 511     arbitrary = NodeSearch <$> arbitrary <*> arbitrary <*> arbitrary
 512                      <*> arbitrary <*> arbitrary <*> arbitrary
 513                      <*> arbitrary <*> arbitrary
 514
 515
 516 ------------------------------------------------------------------------
 517 hyperdataDocument :: HyperdataDocument
 518 hyperdataDocument = case decode docExample of
 519                       Just hp -> hp
 520                       Nothing -> HyperdataDocument Nothing Nothing Nothing Nothing
 521                                                    Nothing Nothing Nothing Nothing
 522                                                    Nothing Nothing Nothing Nothing
 523                                                    Nothing Nothing Nothing Nothing
 524                                                    Nothing Nothing Nothing
 525 docExample :: ByteString
 526 docExample = "{\"doi\":\"sdfds\",\"publication_day\":6,\"language_iso2\":\"en\",\"publication_minute\":0,\"publication_month\":7,\"language_iso3\":\"eng\",\"publication_second\":0,\"authors\":\"Nils Hovdenak, Kjell Haram\",\"publication_year\":2012,\"publication_date\":\"2012-07-06 00:00:00+00:00\",\"language_name\":\"English\",\"realdate_full_\":\"2012 01 12\",\"source\":\"European journal of obstetrics, gynecology, and reproductive biology\",\"abstract\":\"The literature was searched for publications on minerals and vitamins during pregnancy and the possible influence of supplements on pregnancy outcome.\",\"title\":\"Influence of mineral and vitamin supplements on pregnancy outcome.\",\"publication_hour\":0}"
 527
 528 instance ToSchema HyperdataCorpus where
 529   declareNamedSchema proxy =
 530     genericDeclareNamedSchema (unPrefixSwagger "hyperdataCorpus_") proxy
 531     & mapped.schema.description ?~ "a corpus"
 532     & mapped.schema.example ?~ toJSON hyperdataCorpus
 533
 534 instance ToSchema HyperdataAnnuaire where
 535   declareNamedSchema proxy =
 536     genericDeclareNamedSchema (unPrefixSwagger "hyperdataAnnuaire_") proxy
 537     & mapped.schema.description ?~ "an annuaire"
 538     & mapped.schema.example ?~ toJSON hyperdataAnnuaire
 539
 540 instance ToSchema HyperdataDocument where
 541   declareNamedSchema proxy =
 542     genericDeclareNamedSchema (unPrefixSwagger "_hyperdataDocument_") proxy
 543     & mapped.schema.description ?~ "a document"
 544     & mapped.schema.example ?~ toJSON hyperdataDocument
 545
 546 instance ToSchema HyperdataAny where
 547   declareNamedSchema proxy =
 548     pure $ genericNameSchema defaultSchemaOptions proxy mempty
 549              & schema.description ?~ "a node"
 550              & schema.example ?~ emptyObject -- TODO
 551
 552
 553 instance ToSchema hyperdata =>
 554          ToSchema (NodePoly NodeId NodeTypeId
 555                             (Maybe UserId)
 556                             ParentId NodeName
 557                             UTCTime hyperdata
 558                   ) where
 559   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_node_")
 560
 561 instance ToSchema hyperdata =>
 562          ToSchema (NodePoly NodeId NodeTypeId
 563                             UserId
 564                             (Maybe ParentId) NodeName
 565                             UTCTime hyperdata
 566                   ) where
 567   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_node_")
 568
 569
 570 instance ToSchema hyperdata =>
 571          ToSchema (NodePolySearch NodeId NodeTypeId
 572                             (Maybe UserId)
 573                             ParentId NodeName
 574                             UTCTime hyperdata (Maybe TSVector)
 575                   ) where
 576   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_ns_")
 577
 578 instance ToSchema hyperdata =>
 579          ToSchema (NodePolySearch NodeId NodeTypeId
 580                             UserId
 581                             (Maybe ParentId) NodeName
 582                             UTCTime hyperdata (Maybe TSVector)
 583                   ) where
 584   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_ns_")
 585
 586
 587 instance ToSchema Status where
 588   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "status_")
 589
 590