schema.graphql

scalar DateTime
scalar Upload

scalar Latitude
scalar Longitude

""" These unions are a way for a property to hold references to different types """
union Enterable = Group | Person | Reference | Schema | Character | State | Description | CharacterInstance | Specimen | Collection

union Groupable = Reference | Schema | Character | State | Description | CharacterInstance | Specimen | Collection

union Authorable = Reference | Schema

union Statable = Character | State

union Characterable = Schema | Character

union Citer = Schema | Description | Specimen

union Commentable = Synonym | Comment

type Group {
    pbotID: ID!
    name: String
    purpose: String
    members: [Person!]! @relation(name: "MEMBER_OF", direction: IN)
    elements: [Groupable!]! @relation(name: "ELEMENT_OF", direction: IN)
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [GroupEnteredBy]
}

""" Note that I had to use the cypher directive to populate the entered property.
    Ideally, this would be handled by a relation directive, but that does not appear to
    work with unions. """
type Person {
    pbotID: ID!
    password: String
    given: String
    middle: String
    surname: String
    email: String
    orcid: String
    reason: String
    bio: String
    registered: Boolean @cypher(
      statement: "return this.password is not null"
    )
    entered:   [Enterable] @cypher(
      statement: "match (n)-[:ENTERED_BY]->(this) return n"
    )
    authored: [Authorable!]! @relation(name: "AUTHORED_BY", direction: IN)
    identified: [Specimen] @relation(name: "HAS_IDENTIFIED", direction: OUT)
    memberOf: [Group] @relation(name: "MEMBER_OF", direction: OUT)
    enteredBy: [PersonEnteredBy]
}

type Reference {
    pbotID: ID!
    title: String
    year: String
    publicationType: String
    firstPage: String
    lastPage: String
    journal: String
    bookTitle: String
    publicationVolume: String
    publicationNumber: String
    publisher: String
    description: String
    bookType: String
    editors: String
    notes: String
    doi: String
    pbdbid: String
    citedBy: [Citer!]! @relation(name: "CITED_BY", direction: OUT)
    authoredBy: [ReferenceAuthoredBy!]!
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [ReferenceEnteredBy]
}

type Schema {
    pbotID: ID!
    title: String
    year: String
    acknowledgments: String
    purpose: String
    partsPreserved: [Organ] @relation(name: "HAS_PART", direction: OUT)
    notableFeatures: [Feature] @relation(name: "HAS_FEATURE", direction: OUT)
    references: [SchemaCitedBy]
    characters: [Character] @relation(name: "CHARACTER_OF", direction: IN)
    authoredBy: [SchemaAuthoredBy]
    appliedBy: [Description]! @relation(name: "APPLICATION_OF", direction: IN)
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [SchemaEnteredBy]
}

type Character {
    pbotID: ID!
    name: String
    definition: String
    order: String
    deepOrder: String @cypher(
      statement: """
        MATCH path = (this)-[:CHARACTER_OF*0..]->(root:Character)
        WITH nodes(path) AS ns
        ORDER BY length(path) DESC
        LIMIT 1
        WITH [n IN reverse(ns) | n.order] AS orders
        RETURN apoc.text.join(orders, ".")
      """
    )
    characterOf: Characterable! @cypher(
      statement: "match (this)-[:CHARACTER_OF]->(n) return n limit 1"
    )
    characters: [Character!]! @relation(name: "CHARACTER_OF", direction: IN)
    states: [State!]! @relation(name: "STATE_OF", direction: IN)
    characterInstances: [CharacterInstance!]! @relation(name: "INSTANCE_OF" direction: IN)
    enteredBy: [CharacterEnteredBy]
}

type State {
    pbotID: ID!
    name: String
    definition: String
    order: String
    deepOrder: String @cypher(
      statement: """
        MATCH path = (this)-[:STATE_OF*0..]->(root:State)
        WITH nodes(path) AS ns
        ORDER BY length(path) DESC
        LIMIT 1
        WITH [n IN reverse(ns) | n.order] AS orders
        RETURN apoc.text.join(orders, ".")
      """
    )
    stateOf:  Statable! @cypher(
      statement: "match (this)-[:STATE_OF]->(n) return n limit 1"
    )
    states: [State!]! @relation(name: "STATE_OF", direction: IN)
    characterInstances: [HasState]
    enteredBy: [StateEnteredBy]
}

""" Description Complex types """
type Organ {
    pbotID: ID!
    type: String
    specimens: [Specimen!]! @relation(name: "HAS_PART" direction: IN)
    otus: [OTU!]! @relation(name: "HAS_PART" direction: IN)
    enteredBy: [OrganEnteredBy]
}

type Feature {
    pbotID: ID!
    name: String
    specimens: [Specimen!]! @relation(name: "HAS_FEATURE" direction: IN)
    otus: [OTU!]! @relation(name: "HAS_FEATURE" direction: IN)
    enteredBy: [FeatureEnteredBy]
}

type PreservationMode {
    pbotID: ID!
    name: String
    specimens: [Specimen!]! @relation(name: "PRESERVED_BY" direction: IN)
    enteredBy: [PreservationModeEnteredBy]
}

"""Note: schema should be non null, but isn't right now due to missing data"""
type Description {
    pbotID: ID!
    name: String
    writtenDescription: String
    notes: String
    characterInstances: [CharacterInstance!]! @relation(name: "DEFINED_BY", direction: OUT)
    specimens: [DescribedBy]
    schema: Schema @relation(name: "APPLICATION_OF", direction: OUT)
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    references: [DescriptionCitedBy]
    enteredBy: [DescriptionEnteredBy]
}

type CharacterInstance {
    pbotID: ID!
    character: Character @relation(name: "INSTANCE_OF", direction: OUT)
    state: HasState
    candidateForArchtype: Description @relation(name: "CANDIDATE_FOR", direction: OUT)
    description: Description @relation(name: "DEFINED_BY" direction: IN)
    enteredBy: [CharacterInstanceEnteredBy]
}

type PseudoCharacterInstance {
    schema: String
    characterName: String
    characterID: String
    characterDeepOrder: String
    stateDeepOrder: String
    stateName: String
    stateID: String
    stateOrder: String
    stateValue: String
}

"""Note: Ideally, we'd return this for mergedDescription, but neo4j-graphql-js seems to choke when
types are nested more than one level. Keeping it here as a reminder down the line."""
type PseudoDescription {
    schema: String!
    characterInstances: [PseudoCharacterInstance!]!
}

type OTU {
    pbotID: ID!
    name: String
    authority: String
    diagnosis: String
    qualityIndex: String
    majorTaxonGroup: String
    pbdbParentTaxon: String
    family: String
    genus: String
    pfnGenusLink: String
    species: String
    pfnSpeciesLink: String
    additionalClades: String
    identifiedSpecimens: [IdentifiedSpecimenOf!]!
    typeSpecimens: [TypeSpecimenOf!]!
    holotypeSpecimen: HolotypeSpecimenOf
    synonyms: [Synonym] @relation(name: "SAME_AS", direction: OUT)
    references: [OTUCitedBy]
    partsPreserved: [Organ] @relation(name: "HAS_PART", direction: OUT)
    notableFeatures: [Feature] @relation(name: "HAS_FEATURE", direction: OUT)
    notes: String
    mergedDescription: [PseudoCharacterInstance!]! @cypher(
        statement: """
            MATCH
                (otu:OTU {pbotID:this.pbotID})<-[:TYPE_OF|:HOLOTYPE_OF]-(specimen:Specimen)-[:DESCRIBED_BY]->(d:Description)
            WITH
                DISTINCT d //This gets rid of possible TYPE_OF/HOLOTYPE_OF duplicates
            MATCH   
                (d)-[:DEFINED_BY]->(ci:CharacterInstance),
                (ci)-[:INSTANCE_OF]->(c:Character),
                (ci)-[hs:HAS_STATE]->(s:State),
                (d)-[:APPLICATION_OF]->(schema:Schema) 
            WITH
                DISTINCT c, schema, s, hs.value AS stateValue, hs.order AS stateOrder
                
            // Combined subquery for both Character and State deepOrder
            CALL {
                WITH c, s
                // Calculate Character deepOrder
                MATCH path1 = (c)-[:CHARACTER_OF*0..]->(rootChar:Character)
                WITH c, s, path1
                ORDER BY length(path1) DESC
                LIMIT 1
                
                // Calculate State deepOrder
                MATCH path2 = (s)-[:STATE_OF*0..]->(rootState:State)
                WITH c, s, path1, path2
                ORDER BY length(path2) DESC
                LIMIT 1
                
                RETURN 
                    c.pbotID AS charID,
                    s.pbotID AS stateID, 
                    apoc.text.join([n IN reverse(nodes(path1)) | n.order], ".") AS charDeepOrder,
                    apoc.text.join([n IN reverse(nodes(path2)) | n.order], ".") AS stateDeepOrder
            }
                
            RETURN
                { 
                    schema: schema.title,
                    characterName: c.name,
                    characterID: c.pbotID,
                    characterDeepOrder: charDeepOrder,
                    stateName: s.name,
                    stateID: s.pbotID,
                    stateOrder: stateOrder,
                    stateDeepOrder: stateDeepOrder,
                    stateValue: stateValue
                } AS md
        """
    )    
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [OTUEnteredBy]
}

type Synonym {
    pbotID: ID!
    explanation: String
    comments: [Comment!] @relation(name: "REFERS_TO", direction: IN)
    references: [SynonymCitedBy]
    otus: [OTU!]! @relation(name: "SAME_AS", direction: IN)
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [SynonymEnteredBy]
}

type Comment {
    pbotID: ID!
    content: String
    subject: Commentable! @cypher(
      statement: "match (this)-[:REFERS_TO]->(n) return n limit 1"
    )    
    references: [CommentCitedBy]
    comments: [Comment!] @relation(name: "REFERS_TO", direction: IN)
    enteredBy: [CommentEnteredBy]
}

type Specimen {
    pbotID: ID!
    name: String
    specimenNumber: String @cypher(
      statement: "return this.name"
    )
    preservationModes: [PreservationMode] @relation(name: "PRESERVED_BY", direction: OUT)
    repository: String
    otherRepositoryLink: String
    notes: String
    gbifID: String
    idigbioInstitutionCode: String
    idigbioCatalogNumber: String
    idigbiouuid: String
    pbdbcid: String
    pbdboccid: String
    partsPreserved: [Organ] @relation(name: "HAS_PART", direction: OUT)
    notableFeatures: [Feature] @relation(name: "HAS_FEATURE", direction: OUT)
    images: [Image] @relation(name: "IMAGE_OF", direction: IN)
    describedBy: [DescribedBy]
    identifiedAs: [IdentifiedSpecimenOf]
    typeOf: [TypeSpecimenOf]
    holotypeOf: [HolotypeSpecimenOf]
    identifiers: [Person] @relation(name: "HAS_IDENTIFIED", direction: IN)
    references: [SpecimenCitedBy]
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    collection: Collection! @relation(name: "COLLECTED_IN", direction: OUT)
    enteredBy: [SpecimenEnteredBy]
}

type Image {
    pbotID: ID!
    link: String!
    category: String
    citation: String
    caption: String
    type: String
    imageOf: Specimen! @relation(name: "IMAGE_OF", direction: OUT)
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
}

"""Note: lat and lon have been replaced by location. Keeping them here with @cyphers for api consistency. """
type Collection {
    pbotID: ID!
    name: String!
    collectionType: String
    sizeClasses: [String]
    timescale: String
    mininterval: String
    maxinterval: String
    lithology: String
    additionalLithology: String
    stratigraphicGroup: String
    stratigraphicFormation: String
    stratigraphicMember: String
    stratigraphicBed: String
    stratigraphicComments: String
    preservationModes: [PreservationMode] @relation(name: "PRESERVED_BY", direction: OUT)
    environment: String
    environmentComments: String
    collectors: String
    collectionMethods: [String]
    collectingComments: String
    lat: Latitude @cypher(statement: "match (this) return this.location.latitude")
    lon: Longitude @cypher(statement: "match (this) return this.location.longitude")
    location: Point
    gpsCoordinateUncertainty: Float
    geographicResolution: String
    geographicComments: String
    directDate: Float
    directDateError: Float
    directDateType: String
    numericAgeMin: Float
    numericAgeMinError: Float
    numericAgeMinType: String
    numericAgeMax: Float
    numericAgeMaxError: Float
    numericAgeMaxType: String
    ageComments: String
    protectedSite: Boolean
    country: String
    state: String
    pbdbid: String
    specimens: [Specimen] @relation(name: "COLLECTED_IN", direction: IN)
    references: [CollectionCitedBy!]!
    elementOf: [Group!]! @relation(name: "ELEMENT_OF", direction: OUT)
    enteredBy: [CollectionEnteredBy]
}


""" In order to access relationship properties, the relationship must be specified with a standalone type.
    Ideally, there would be one of these for the ENTERED_BY relationship, with the Enterable union in the
    from property. That does not work. So, I've had to resort to creating a separate type for each node type
    that could be in the from property. I'm not sure of the cons here. It looks like crap though. """
type GroupEnteredBy @relation(name: "ENTERED_BY") {
  from: Group
  to: Person
  timestamp: DateTime
  type: String
}

type PersonEnteredBy @relation(name: "ENTERED_BY") {
  from: Person
  to: Person
  timestamp: DateTime
  type: String
}

type ReferenceEnteredBy @relation(name: "ENTERED_BY") {
  from: Reference
  to: Person
  timestamp: DateTime
  type: String
}

type SchemaEnteredBy @relation(name: "ENTERED_BY") {
  from: Schema
  to: Person
  timestamp: DateTime
  type: String
}

type CharacterEnteredBy @relation(name: "ENTERED_BY") {
  from: Character
  to: Person
  timestamp: DateTime
  type: String
}

type StateEnteredBy @relation(name: "ENTERED_BY") {
  from: State
  to: Person
  timestamp: DateTime
  type: String
}

type OrganEnteredBy @relation(name: "ENTERED_BY") {
  from: Organ
  to: Person
  timestamp: DateTime
  type: String
}

type FeatureEnteredBy @relation(name: "ENTERED_BY") {
  from: Feature
  to: Person
  timestamp: DateTime
  type: String
}

type PreservationModeEnteredBy @relation(name: "ENTERED_BY") {
  from: PreservationMode
  to: Person
  timestamp: DateTime
  type: String
}

type DescriptionEnteredBy @relation(name: "ENTERED_BY") {
  from: Description
  to: Person
  timestamp: DateTime
  type: String
}

type CharacterInstanceEnteredBy @relation(name: "ENTERED_BY") {
  from: CharacterInstance
  to: Person
  timestamp: DateTime
  type: String
}

type SpecimenEnteredBy @relation(name: "ENTERED_BY") {
  from: Specimen
  to: Person
  timestamp: DateTime
  type: String
}

type CollectionEnteredBy @relation(name: "ENTERED_BY") {
  from: Collection
  to: Person
  timestamp: DateTime
  type: String
}

type OTUEnteredBy @relation(name: "ENTERED_BY") {
  from: OTU
  to: Person
  timestamp: DateTime
  type: String
}

type SynonymEnteredBy @relation(name: "ENTERED_BY") {
  from: Synonym
  to: Person
  timestamp: DateTime
  type: String
}

type CommentEnteredBy @relation(name: "ENTERED_BY") {
  from: Comment
  to: Person
  timestamp: DateTime
  type: String
}

"""AUTHORED_BY for access to order"""
type ReferenceAuthoredBy @relation(name: "AUTHORED_BY") {
  from: Reference
  to: Person
  order: String
}

type SchemaAuthoredBy @relation(name: "AUTHORED_BY") {
  from: Schema
  to: Person
  order: String
}

"""CITED_BY for access to order"""
type SchemaCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Schema
  order: String
}

type DescriptionCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Description
  order: String
}

type SpecimenCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Specimen
  order: String
}

type CollectionCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Collection
  order: String
}

type OTUCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: OTU
  order: String
}

type SynonymCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Synonym
  order: String
}

type CommentCitedBy @relation(name: "CITED_BY") {
  from: Reference
  to: Comment
  order: String
}


""" HAS_STATE for access to value and order"""
type HasState @relation(name: "HAS_STATE") {
    from: CharacterInstance
    to: State
    value: String
    order: String
}


""" IDENTIFIED_AS for access to entered_by and timestamp """
type IdentifiedSpecimenOf @relation(name: "IDENTIFIED_AS") {
    from: Specimen
    to: OTU
    entered_by: ID!
    timestamp: DateTime
}

""" TYPE_OF for access to entered_by and timestamp """
type TypeSpecimenOf @relation(name: "TYPE_OF") {
    from: Specimen
    to: OTU
    entered_by: ID!
    timestamp: DateTime
}

""" HOLOTYPE_OF for access to entered_by and timestamp """
type HolotypeSpecimenOf @relation(name: "HOLOTYPE_OF") {
    from: Specimen
    to: OTU
    entered_by: ID!
    timestamp: DateTime
}

""" DESCRIBED_BY for access to entered_by and timestamp """
type DescribedBy @relation(name: "DESCRIBED_BY") {
    from: Specimen
    to: Description
    entered_by: ID!
    timestamp: DateTime
}



type Query {        
    
    echoLat(lat: Latitude!): Latitude!
    echoLon(lon: Longitude!): Longitude!
 
    """
    Not sure this will be useful, but it's a way to get at the leaf states in state hierarchies."""
    GetLeafStates(characterID: String!): [State]
        @cypher(
            statement: """
                match 
                    (:Character {pbotID: $characterID})<-[:STATE_OF*1..100]-(n:State) 
                where  
                    not (n)<-[:STATE_OF]-(:State) 
                return n            
            """
        )

    GetAllStates(characterID: String!): [State]
        @cypher(
            statement: """
                match 
                    (:Character {pbotID: $characterID})<-[:STATE_OF*1..100]-(n:State) 
                return n            
            """
        )

    GetAllCharacters(schemaID: String!): [Character]
        @cypher(
            statement: """
                match 
                    (:Schema {pbotID: $schemaID})<-[:CHARACTER_OF*1..100]-(n:Character) 
                return n            
            """
        )

    GetAllComments(synonymID: String!): [Comment]
        @cypher(
            statement: """
                match 
                    (:Synonym {pbotID: $synonymID})<-[:REFERS_TO*1..100]-(n:Comment) 
                return n            
            """
        )

    GetNodeCount(nodeType: String!): Int
        @cypher(
            statement: """
                CALL apoc.when(
                    'Contributor' = $nodeType, 
                    'match (n:Person) where n.password is not null return count(n)', 
                    'match (n) where $nodeType in labels(n) return count(n)',
                    {nodeType:$nodeType}
                ) yield value 
                return value.`count(n)`           
            """
        )

}


""" //////////////////////////////////////////////////////////////////////////////////////////////////////
Mutations overrides. We might want to think about only using these, rather than any generated mutations. 
    TODO: To make these true overrides, delete the 'Custom' prefix. """

input GroupInput {
    pbotID: String
    name: String
    purpose: String
    members: [String]
    elements: [String]
    groups: [String]
    enteredByPersonID: String
}

input PersonInput {
    pbotID: String
    given: String
    middle: String
    surname: String
    email: String
    orcid: String
    reason: String
    bio: String
    enteredByPersonID: String
} 

input AuthoredBy {
    pbotID: String
    order: String
}

input ReferenceInput {
    pbotID: String
    title: String
    year: String
    publicationType: String
    firstPage: String
    lastPage: String
    journal: String
    bookTitle: String
    publicationVolume: String
    publicationNumber: String
    publisher: String
    description: String
    bookType: String
    editors: String
    notes: String
    doi: String
    pbdbid: String
    authors: [AuthoredBy!]!
    groups: [String]
    enteredByPersonID: String
} 

input CitedByInput {
    pbotID: String
    order: String
}

input SchemaInput {
    pbotID: String
    title: String!
    year: String
    acknowledgments: String
    purpose: String!
    partsPreservedIDs: [String!]!
    notableFeaturesIDs: [String]
    references: [CitedByInput!]!
    authors: [AuthoredBy]
    groups: [String]
    enteredByPersonID: String
    cascade: Boolean
}

input CharacterInput {
    pbotID: String
    name: String
    definition: String
    order: String
    parentID: String
    schemaID: String
    enteredByPersonID: String
    cascade: Boolean
}

input StateInput {
    pbotID: String
    name: String
    definition: String
    order: String
    parentID: String
    schemaID: String
    enteredByPersonID: String
    cascade: Boolean
}

input DescriptionInput {
    pbotID: String
    specimenIDs: [String]
    name: String!
    writtenDescription: String
    notes: String
    schemaID: String!
    references: [CitedByInput]
    groups: [String]
    enteredByPersonID: String
    cascade: Boolean
}

input CharacterInstanceInput {
    pbotID: String
    descriptionID: String!
    characterID: String!
    stateID: String!
    quantity: String
    order: String
    enteredByPersonID: String
}

input OTUInput {
    pbotID: String
    name: String!
    authority: String!
    diagnosis: String!
    qualityIndex: String!
    majorTaxonGroup: String!
    pbdbParentTaxon: String!
    family: String
    genus: String
    pfnGenusLink: String
    species: String
    pfnSpeciesLink: String
    additionalClades: String
    identifiedSpecimens: [String]
    typeSpecimens: [String]
    holotypeSpecimen: String
    synonyms: [String]
    references: [CitedByInput!]!
    partsPreservedIDs: [String!]!
    notableFeaturesIDs: [String]
    notes: String
    groups: [String!]!
}

input SynonymInput {
    pbotID: String
    explanation: String
    references: [CitedByInput]
    otus: [String!]!
    groups: [String]
}

input CommentInput {
    pbotID: String
    content: String
    subjectID: String
    references: [CitedByInput]
}

input ImageUpload {
    image: Upload!,
    specimenID: String!,
    order: String
}

type ImageReturn {
    link: String!,
}


input SpecimenInput {
    pbotID: String
    name: String!
    preservationModeIDs: [String!]!
    repository: String!
    otherRepositoryLink: String
    notes: String
    gbifID: String
    idigbioInstitutionCode: String
    idigbioCatalogNumber: String
    idigbiouuid: String
    pbdbcid: String
    pbdboccid: String
    images: [ImageInput]
    descriptionIDs: [String]
    partsPreservedIDs: [String!]!
    notableFeaturesIDs: [String]
    identifiers: [String]
    references: [CitedByInput]
    collection: String!
    uploadImages: [ImageUpload]
    groups: [String]
    enteredByPersonID: String
    cascade: Boolean
}

input ImageInput {
    pbotID: String
    link: String
    image: Upload
    category: String
    citation: String
    caption: String
    type: String
    groups: [String]
    imageOf: String
}

input OrganInput {
    pbotID: String
    type: String!
    enteredByPersonID: String
}

input FeatureInput {
    pbotID: String
    name: String!
    enteredByPersonID: String
}

input PreservationModeInput {
    pbotID: String
    name: String!
    enteredByPersonID: String
}

"""Note: location is required, but it shown optional here for api consistency. This is caught in resolver."""
input CollectionInput {
    pbotID: String
    name: String!
    collectionType: String!
    sizeClasses: [String!]!
    timescale: String!
    mininterval: String
    maxinterval: String!
    lithology: String!
    additionalLithology: String
    stratigraphicGroup: String
    stratigraphicFormation: String
    stratigraphicMember: String
    stratigraphicBed: String
    stratigraphicComments: String
    preservationModeIDs: [String!]!
    environment: String
    environmentComments: String
    collectors: String
    collectionMethods: [String]
    collectingComments: String
    lat: Latitude
    lon: Longitude
    location: Point
    gpsCoordinateUncertainty: Float!
    geographicResolution: String
    geographicComments: String
    directDate: Float
    directDateError: Float
    directDateType: String
    numericAgeMin: Float
    numericAgeMinError: Float
    numericAgeMinType: String
    numericAgeMax: Float
    numericAgeMaxError: Float
    numericAgeMaxType: String
    ageComments: String
    protectedSite: Boolean!
    country: String!
    state: String
    pbdbid: String
    references: [CitedByInput]
    groups: [String]
    enteredByPersonID: String
    cascade: Boolean
}

  type File {
    filename: String!
    mimetype: String!
    encoding: String!
  }


type Mutation {
    singleUpload(file: Upload!): File!

    CreateGroup(data: GroupInput!): Group! @neo4j_ignore
    UpdateGroup(data: GroupInput!): Group!  @neo4j_ignore
    DeleteGroup(data: GroupInput!): Group! @neo4j_ignore

        
    CreatePerson(data: PersonInput!): Person! @neo4j_ignore
    UpdatePerson(data: PersonInput!): Person! @neo4j_ignore
    DeletePerson(data: PersonInput!): Person! @neo4j_ignore

    CreateReference(data: ReferenceInput!): Reference! @neo4j_ignore
    UpdateReference(data: ReferenceInput!): Reference! @neo4j_ignore
    DeleteReference(data: ReferenceInput!): Reference! @neo4j_ignore

    CreateSchema(data: SchemaInput!): Schema! @neo4j_ignore
    UpdateSchema(data: SchemaInput!): Schema! @neo4j_ignore
    DeleteSchema(data: SchemaInput!): Schema! @neo4j_ignore
    
    CreateCharacter(data: CharacterInput!): Character! @neo4j_ignore
    UpdateCharacter(data: CharacterInput!): Character! @neo4j_ignore
    DeleteCharacter(data: CharacterInput!): Character! @neo4j_ignore

    CreateState(data: StateInput!): State! @neo4j_ignore
    UpdateState(data: StateInput!): State! @neo4j_ignore
    DeleteState(data: StateInput!): State! @neo4j_ignore

    CreateOTU(data: OTUInput!): OTU! @neo4j_ignore
    UpdateOTU(data: OTUInput!): OTU! @neo4j_ignore
    DeleteOTU(data: OTUInput!): OTU!  @neo4j_ignore

    CreateSynonym(data: SynonymInput!): Synonym! @neo4j_ignore
    UpdateSynonym(data: SynonymInput!): Synonym! @neo4j_ignore
    DeleteSynonym(data: SynonymInput!): Synonym!  @neo4j_ignore

    CreateComment(data: CommentInput!): Comment! @neo4j_ignore
    UpdateComment(data: CommentInput!): Comment! @neo4j_ignore
    DeleteComment(data: CommentInput!): Comment!  @neo4j_ignore

    CreateDescription(data: DescriptionInput!): Description! @neo4j_ignore
    UpdateDescription(data: DescriptionInput!): Description! @neo4j_ignore
    DeleteDescription(data: DescriptionInput!): Description!  @neo4j_ignore

    """NOTE: Keeping CharacterInstance create and update here rather than in Resolvers.js because of the need 
    to check that the State is associated with the Character. It's too specific to fit with the generic approach 
    of the cypher-building code in Resolvers.js. Similarly, recording the old value of HAS_STATE for a quantity
    State is also too specific.
    NOTE: That last sentence is no longer accurate. We are now generically recording relationship states where they occur."""
    CreateCharacterInstance(data: CharacterInstanceInput!): CharacterInstance!
        @cypher(
            statement: """
                MATCH 
                    (description:Description {pbotID: $data.descriptionID}),
                    (description)-[:ELEMENT_OF]->(group:Group),
                    (character:Character {pbotID: $data.characterID})<-[:CHARACTER_OF*0..]-()<-[:STATE_OF*1..]-(state:State {pbotID: $data.stateID}),
                    (person:Person {pbotID: $data.enteredByPersonID})
                WITH
                    collect(group) AS groups, description, character, state, person
                CREATE 
                    (description)-[:DEFINED_BY]->(characterInstance:CharacterInstance {
                        pbotID: apoc.create.uuid()
                    })-[:ENTERED_BY {timestamp: datetime(), type:"CREATE"}]->(person),
                    (character)<-[:INSTANCE_OF]-(characterInstance),
                    (state)<-[:HAS_STATE {value: $data.quantity, order: $data.order}]-(characterInstance) 
                WITH groups, characterInstance
                FOREACH (group IN groups |
                    CREATE	
                        (characterInstance)-[:ELEMENT_OF]->(group)
                )
                RETURN characterInstance
            """
        )
    UpdateCharacterInstance(data: CharacterInstanceInput!): CharacterInstance! 
        @cypher(
            statement: """
                MATCH 
                    (characterInstance:CharacterInstance {pbotID: $data.pbotID}),
                    (ePerson:Person {pbotID: $data.enteredByPersonID})
                WITH characterInstance, ePerson					
                CREATE
                    (characterInstance)-[eb:ENTERED_BY {timestamp: datetime(), type:"EDIT"}]->(ePerson)
                WITH characterInstance, eb
                OPTIONAL MATCH
                    (oldCharacter:Character)<-[oldCharacterRelationship:INSTANCE_OF]-(characterInstance)
                DELETE oldCharacterRelationship
                WITH characterInstance, eb, oldCharacter					
                    CALL apoc.do.case([
                            oldCharacter IS NULL AND $data.characterID IS NOT NULL,
                            "SET eb.character = 'not present' RETURN eb",
                            oldCharacter IS NOT NULL AND ($data.characterID IS NULL OR oldCharacter.pbotID  <> $data.characterID),
                            "SET eb.character = oldCharacter.pbotID RETURN eb"],
                            "RETURN eb",
                            {oldCharacter: oldCharacter, eb: eb}
                        ) YIELD value
                WITH characterInstance, eb					
                OPTIONAL MATCH
                    (oldState:State)<-[oldStateRelationship:HAS_STATE]-(characterInstance)
                WITH characterInstance, eb, oldState, oldStateRelationship				
                    CALL apoc.do.case([
                            oldState IS NULL AND $data.stateID IS NOT NULL,
                            "SET eb.state = 'not present' RETURN eb",
                            oldState IS NOT NULL AND ($data.stateID IS NULL OR oldState.pbotID  <> $data.stateID OR (oldStateRelationship.value IS NOT NULL AND oldStateRelationship.value <> $data.quantity) OR (oldStateRelationship.order IS NOT NULL AND oldStateRelationship.order <> $data.order)),
                            "SET eb.state = oldState.pbotID, eb.value = oldStateRelationship.value, eb.order = oldStateRelationship.order RETURN eb"],
                            "RETURN eb",
                            {oldState: oldState, oldStateRelationship: oldStateRelationship, eb: eb}
                        ) YIELD value
                        DELETE oldStateRelationship
                WITH characterInstance
                MATCH
                    (character:Character {pbotID: $data.characterID})<-[:CHARACTER_OF*0..]-()<-[:STATE_OF*1..]-(state:State {pbotID: $data.stateID})
                CREATE 
                    (character)<-[:INSTANCE_OF]-(characterInstance),
                    (state)<-[:HAS_STATE {value: $data.quantity, order: $data.order}]-(characterInstance) 
                RETURN characterInstance
            """
        )
    DeleteCharacterInstance(data: CharacterInstanceInput!): CharacterInstance! @neo4j_ignore

    CreateSpecimen(data: SpecimenInput!): Specimen! @neo4j_ignore
    UpdateSpecimen(data: SpecimenInput!): Specimen! @neo4j_ignore
    DeleteSpecimen(data: SpecimenInput!): Specimen! @neo4j_ignore

    CreateCollection(data: CollectionInput!): Collection! @neo4j_ignore
    UpdateCollection(data: CollectionInput!): Collection!  @neo4j_ignore
    DeleteCollection(data: CollectionInput!): Collection! @neo4j_ignore

    CreateOrgan(data: OrganInput!): Organ! @neo4j_ignore
    UpdateOrgan(data: OrganInput!): Organ! @neo4j_ignore
    DeleteOrgan(data: OrganInput!): Organ! @neo4j_ignore

    CreateFeature(data: FeatureInput!): Feature! @neo4j_ignore
    UpdateFeature(data: FeatureInput!): Feature! @neo4j_ignore
    DeleteFeature(data: FeatureInput!): Feature! @neo4j_ignore

    CreatePreservationMode(data: PreservationModeInput!): PreservationMode! @neo4j_ignore
    UpdatePreservationMode(data: PreservationModeInput!): PreservationMode! @neo4j_ignore
    DeletePreservationMode(data: PreservationModeInput!): PreservationMode! @neo4j_ignore

    CreateImage(data: ImageInput!): Image! @neo4j_ignore
    UpdateImage(data: ImageInput!): Image! @neo4j_ignore
    DeleteImage(data: ImageInput!): Image! @neo4j_ignore

    UploadImage(image: Upload!, specimenID: String!): ImageReturn! @neo4j_ignore
}