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   deriving (Show, Read, Eq, Generic, Bounded, Enum)
 448
 449
 450 {-
 451               -- | Metrics
 452               -- | NodeOccurrences
 453               -- | Classification
 454 -}
 455
 456 allNodeTypes :: [NodeType]
 457 allNodeTypes = [minBound ..]
 458
 459 instance FromJSON NodeType
 460 instance ToJSON NodeType
 461
 462 instance FromHttpApiData NodeType
 463   where
 464       parseUrlPiece = Right . read . unpack
 465
 466 instance ToParamSchema NodeType
 467 instance ToSchema      NodeType
 468
 469
 470 data NodePolySearch id        typename userId
 471               parentId  name     date
 472               hyperdata search = NodeSearch { _ns_id        :: id
 473                                       , _ns_typename  :: typename
 474                                       , _ns_userId    :: userId
 475                                                                 --   , nodeUniqId    :: shaId
 476                                       , _ns_parentId  :: parentId
 477                                       , _ns_name      :: name
 478                                       , _ns_date      :: date
 479
 480                                       , _ns_hyperdata :: hyperdata
 481                                       , _ns_search    :: search
 482                                       } deriving (Show, Generic)
 483 $(deriveJSON (unPrefix "_ns_") ''NodePolySearch)
 484 $(makeLenses ''NodePolySearch)
 485
 486 type NodeSearch json   = NodePolySearch NodeId NodeTypeId UserId (Maybe ParentId) NodeName UTCTime json (Maybe TSVector)
 487 ------------------------------------------------------------------------
 488
 489
 490 instance (Arbitrary hyperdata
 491          ,Arbitrary nodeId
 492          ,Arbitrary nodeTypeId
 493          ,Arbitrary userId
 494          ,Arbitrary nodeParentId
 495          ) => Arbitrary (NodePoly nodeId nodeTypeId userId nodeParentId
 496                                   NodeName UTCTime hyperdata) where
 497     --arbitrary = Node 1 1 (Just 1) 1 "name" (jour 2018 01 01) (arbitrary) (Just "")
 498     arbitrary = Node <$> arbitrary <*> arbitrary <*> arbitrary
 499                      <*> arbitrary <*> arbitrary <*> arbitrary
 500                      <*> arbitrary
 501
 502 instance (Arbitrary hyperdata
 503          ,Arbitrary nodeId
 504          ,Arbitrary nodeTypeId
 505          ,Arbitrary userId
 506          ,Arbitrary nodeParentId
 507          ) => Arbitrary (NodePolySearch nodeId nodeTypeId userId nodeParentId
 508                                   NodeName UTCTime hyperdata (Maybe TSVector)) where
 509     --arbitrary = Node 1 1 (Just 1) 1 "name" (jour 2018 01 01) (arbitrary) (Just "")
 510     arbitrary = NodeSearch <$> arbitrary <*> arbitrary <*> arbitrary
 511                      <*> arbitrary <*> arbitrary <*> arbitrary
 512                      <*> arbitrary <*> arbitrary
 513
 514
 515 ------------------------------------------------------------------------
 516 hyperdataDocument :: HyperdataDocument
 517 hyperdataDocument = case decode docExample of
 518                       Just hp -> hp
 519                       Nothing -> HyperdataDocument Nothing Nothing Nothing Nothing
 520                                                    Nothing Nothing Nothing Nothing
 521                                                    Nothing Nothing Nothing Nothing
 522                                                    Nothing Nothing Nothing Nothing
 523                                                    Nothing Nothing Nothing
 524 docExample :: ByteString
 525 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}"
 526
 527 instance ToSchema HyperdataCorpus where
 528   declareNamedSchema proxy =
 529     genericDeclareNamedSchema (unPrefixSwagger "hyperdataCorpus_") proxy
 530     & mapped.schema.description ?~ "a corpus"
 531     & mapped.schema.example ?~ toJSON hyperdataCorpus
 532
 533 instance ToSchema HyperdataAnnuaire where
 534   declareNamedSchema proxy =
 535     genericDeclareNamedSchema (unPrefixSwagger "hyperdataAnnuaire_") proxy
 536     & mapped.schema.description ?~ "an annuaire"
 537     & mapped.schema.example ?~ toJSON hyperdataAnnuaire
 538
 539 instance ToSchema HyperdataDocument where
 540   declareNamedSchema proxy =
 541     genericDeclareNamedSchema (unPrefixSwagger "_hyperdataDocument_") proxy
 542     & mapped.schema.description ?~ "a document"
 543     & mapped.schema.example ?~ toJSON hyperdataDocument
 544
 545 instance ToSchema HyperdataAny where
 546   declareNamedSchema proxy =
 547     pure $ genericNameSchema defaultSchemaOptions proxy mempty
 548              & schema.description ?~ "a node"
 549              & schema.example ?~ emptyObject -- TODO
 550
 551
 552 instance ToSchema hyperdata =>
 553          ToSchema (NodePoly NodeId NodeTypeId
 554                             (Maybe UserId)
 555                             ParentId NodeName
 556                             UTCTime hyperdata
 557                   ) where
 558   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_node_")
 559
 560 instance ToSchema hyperdata =>
 561          ToSchema (NodePoly NodeId NodeTypeId
 562                             UserId
 563                             (Maybe ParentId) NodeName
 564                             UTCTime hyperdata
 565                   ) where
 566   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_node_")
 567
 568
 569 instance ToSchema hyperdata =>
 570          ToSchema (NodePolySearch NodeId NodeTypeId
 571                             (Maybe UserId)
 572                             ParentId NodeName
 573                             UTCTime hyperdata (Maybe TSVector)
 574                   ) where
 575   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_ns_")
 576
 577 instance ToSchema hyperdata =>
 578          ToSchema (NodePolySearch NodeId NodeTypeId
 579                             UserId
 580                             (Maybe ParentId) NodeName
 581                             UTCTime hyperdata (Maybe TSVector)
 582                   ) where
 583   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "_ns_")
 584
 585
 586 instance ToSchema Status where
 587   declareNamedSchema = genericDeclareNamedSchema (unPrefixSwagger "status_")
 588
 589