{"id":13529724,"url":"https://github.com/graphaware/neo4j-timetree","last_synced_at":"2025-09-30T10:30:48.944Z","repository":{"id":16599261,"uuid":"19353783","full_name":"graphaware/neo4j-timetree","owner":"graphaware","description":"Java and REST APIs for working with time-representing tree in Neo4j","archived":true,"fork":false,"pushed_at":"2021-05-05T19:20:47.000Z","size":1374,"stargazers_count":206,"open_issues_count":0,"forks_count":41,"subscribers_count":41,"default_branch":"master","last_synced_at":"2024-09-27T21:41:46.373Z","etag":null,"topics":["java","neo4j","neo4j-graphaware-framework"],"latest_commit_sha":null,"homepage":null,"language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":"bangumi-data/bangumi-data","license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/graphaware.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2014-05-01T18:36:55.000Z","updated_at":"2024-02-29T14:29:00.000Z","dependencies_parsed_at":"2022-09-09T09:31:03.341Z","dependency_job_id":null,"html_url":"https://github.com/graphaware/neo4j-timetree","commit_stats":null,"previous_names":[],"tags_count":79,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/graphaware%2Fneo4j-timetree","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/graphaware%2Fneo4j-timetree/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/graphaware%2Fneo4j-timetree/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/graphaware%2Fneo4j-timetree/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/graphaware","download_url":"https://codeload.github.com/graphaware/neo4j-timetree/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":234724892,"owners_count":18877279,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["java","neo4j","neo4j-graphaware-framework"],"created_at":"2024-08-01T07:00:38.853Z","updated_at":"2025-09-30T10:30:43.647Z","avatar_url":"https://github.com/graphaware.png","language":"Java","readme":"GraphAware Neo4j TimeTree - RETIRED\n==========================\n                     \n## GraphAware Neo4j TimeTree Has Been Retired\nAs of May 2021, this [repository has been retired](https://graphaware.com/framework/2021/05/06/from-graphaware-framework-to-graphaware-hume.html).\n\nGraphAware TimeTree is a simple library for representing time in Neo4j as a tree of time instants. The tree is built on-demand,\nsupports resolutions of one year down to one millisecond and has time zone support. It also supports attaching event nodes to time instants (created on demand).\n\n## Community vs Enterprise\n\nThis open-source (GPL) version of the module is compatible with GraphAware Framework Community (GPL), which in turn \nis compatible with Neo4j Community Edition (GPL) only. It *will not work* with Neo4j Enterprise Edition, which is a \nproprietary and commercial software product of Neo4j, Inc..\n\nGraphAware offers an Enterprise version of the GraphAware Framework to licensed users of Neo4j Enterprise Edition.\nPlease [get in touch](mailto:info@graphaware.com) to receive access.\n\nGetting the Software\n--------------------\n\n### Server Mode\n\nWhen using Neo4j in the \u003ca href=\"http://docs.neo4j.org/chunked/stable/server-installation.html\" target=\"_blank\"\u003estandalone server\u003c/a\u003e mode, you will need the \u003ca href=\"https://github.com/graphaware/neo4j-framework\" target=\"_blank\"\u003eGraphAware Neo4j Framework\u003c/a\u003e and GraphAware Neo4j TimeTree .jar files (both of which you can \u003ca href=\"http://graphaware.com/downloads/\" target=\"_blank\"\u003edownload here\u003c/a\u003e) dropped into the `plugins` directory of your Neo4j installation. Starting in version 3.2, Neo4j has increased security for procedures and functions (sandboxing). Procedures that use internal APIs have to be allowed in `$NEO4J_HOME/conf/neoj4.conf`. As an example: `dbms.security.procedures.unrestricted=ga.timetree.*`\n\nAfter adding the required plugins and updating `neo4j.conf`, restart Neo4j and you will be able to use the REST APIs of the TimeTree. Also note the additional, optional, installation instructions in the [Automatic Event Attachment](https://github.com/graphaware/neo4j-timetree#automatic-event-attachment) section.\n\n### Embedded Mode / Java Development\n\nJava developers that use Neo4j in \u003ca href=\"http://docs.neo4j.org/chunked/stable/tutorials-java-embedded.html\" target=\"_blank\"\u003eembedded mode\u003c/a\u003e\nand those developing Neo4j \u003ca href=\"http://docs.neo4j.org/chunked/stable/server-plugins.html\" target=\"_blank\"\u003eserver plugins\u003c/a\u003e,\n\u003ca href=\"http://docs.neo4j.org/chunked/stable/server-unmanaged-extensions.html\" target=\"_blank\"\u003eunmanaged extensions\u003c/a\u003e,\nGraphAware Runtime Modules, or Spring MVC Controllers can include use the TimeTree as a dependency for their Java project.\n\n#### Releases\n\nReleases are synced to \u003ca href=\"http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22timetree%22\" target=\"_blank\"\u003eMaven Central repository\u003c/a\u003e. When using Maven for dependency management, include the following dependency in your pom.xml and edit the version number.\n\n    \u003cdependencies\u003e\n        ...\n        \u003cdependency\u003e\n            \u003cgroupId\u003ecom.graphaware.neo4j\u003c/groupId\u003e\n            \u003cartifactId\u003etimetree\u003c/artifactId\u003e\n            \u003cversion\u003eA.B.C.D.E\u003c/version\u003e\n        \u003c/dependency\u003e\n        ...\n    \u003c/dependencies\u003e\n\n#### Snapshots\n\nTo use the latest development version, just clone this repository, run `mvn clean install` and change the version in the\ndependency above to A.B.C.D.E-SNAPSHOT.\n\n#### Note on Versioning Scheme\n\nThe version number has two parts. The first four numbers indicate compatibility with Neo4j GraphAware Framework.\n The last number is the version of the TimeTree library. For example, version 2.0.3.4.3 is version 3 of the TimeTree\n compatible with GraphAware Neo4j Framework 2.0.3.4.\n\nUsing GraphAware TimeTree\n-------------------------\n\nTimeTree allows you to represent events as nodes and link them to nodes representing instants of time in order to capture\nthe time of the event's occurrence. For instance, if you wanted to express the fact that an email was sent on a specific\nday, you would create a node labelled `Email` and link it to a node labelled `Day` using a `SENT_ON` relationship.\n\n![email linked to day](https://github.com/graphaware/neo4j-timetree/raw/master/docs/image.jpg)\n\nIn order to be able to ask interesting queries, such as \"show me all emails sent in a specific month\", people \u003ca href=\"http://neo4j.com/blog/modeling-a-multilevel-index-in-neoj4/\" target=\"_blank\"\u003eoften built\u003c/a\u003e\na time-tree in Neo4j with a root, years on the first level, months on the second level, etc. Something like this:\n\n![time tree](https://github.com/graphaware/neo4j-timetree/raw/master/docs/image2.jpg)\n\nOne way of building such tree is of course pre-generating it, for instance using a Cypher query. The approach taken by GraphAware TimeTree is to build the tree on-demand, as nodes representing time instants are requested.\nFor example, you can ask the library \"give me a node representing 24th May 2014\". You'll get the node (Java) or its ID (REST) and can start linking to it.\nIn the background, a node representing May (labelled `Month`) and a node representing 2014 (labelled `Year`) will be created,\nif they do not exist. Links between nodes on the same level as well as between levels are automatically maintained.\n\nThere are 4 types of relationships (hopefully self-explanatory):\n* `CHILD`\n* `NEXT`\n* `FIRST`\n* `LAST`\n\nWhen using `SingleTimeTree`, the root of the tree is labelled `TimeTreeRoot`. You can create multiple time trees in your\ngraph, in which case you should use `CustomRootTimeTree` and supply a node from your graph that will serve as the root of the tree.\n\nThe graph above, if generated by GraphAware `SingleTimeTree`, would thus look like this:\n\n![GraphAware TimeTree generated time tree](https://github.com/graphaware/neo4j-timetree/raw/master/docs/image3.jpg)\n\nYou can select the \"resolution\" of the time instant you will get from TimeTree. For instance, you only know that a certain\nevent happened in April, nothing more. In that case, you can request the node representing April. Equally, you can request\nnodes representing concrete millisecond instants, if you so desire.\n\nYou may also provide a time-zone to the TimeTree APIs in order to create correctly labelled nodes for specific time instants.\n\nFinally, the GraphAware TimeTree supports both attaching event nodes to time instants, and fetching events attached\nto a time instant and all its children or between two time instants and all their children. For instance, you can ask\nfor all events that happened in April, which will return events attached to the April node as well as all its children\nand their children, etc.\n\n### Cypher\n\nThe TimeTree plugin offers a series of stored procedures in order to work with instant nodes and events efficiently.\n\n#### Instant nodes\n\nTo get a node representing a time instant :\n\n```\nCALL ga.timetree.single({time: 1463659567468})\n```\n\nIf you would like that the instant node is created if it doesn't exist for the given time, you can user single with option create instead :\n\n```\nCALL ga.timetree.single({time: 1463659567468, create: true})\n```\n\nThis will create the time tree nodes in the graph :\n\n![GraphAware TimeTree procedure merge](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure1.png)\n\nThe following parameters can be passed in the map:\n\n* `time`: (mandatory) the long representation of the time\n* `resolution` : default resolution is `Day`\n* `timezone` : default timezone is `UTC`\n* `root`: by default the time instants are attached to the default TimeTreeRoot, you can pass a node that will be used as time tree root\n* `create`: create the time tree node if not exist, by default to `false`\n\nYou can also get or create a node that represent the current time with the `now()` procedure :\n\n```\nCALL ga.timetree.now({})\n```\n\nExcept for the `time` parameter, all other parameters can be passed in the map\n\nYou can also retrieve a range of instant nodes, by invoking the `range` procedure call :\n\n```\nCALL ga.timetree.range({start: 1463659567468, end: 1463859569504, create: true})\n```\n\nFor the range call, an additional `create` parameter is available (by default to false). If set to true, the instant nodes will be created if they don't exist.\n\n![GraphAware TimeTree range](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure2.png)\n\n#### Attaching events to the time tree\n\nYou can attach any node to a time instant with the `events.attach` procedure call :\n\n```\nCREATE (e:Email {text: \"I used the timetree\"})\nWITH e\nCALL ga.timetree.events.attach({node: e, time: 1463659567468, relationshipType: \"SENT_ON\"})\nYIELD node RETURN node\n```\n\n![GraphAware TimeTree procedure attach](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure3.png)\n\nThe following parameters can be passed in the map :\n\n* `time`: (mandatory) the long representation of the time\n* `node`: (mandatory) the event node to be attached to the time tree\n* `relationshipType`: (mandatory) the name of the relationship type to be created between the event node and the instant node\n* `direction`: default to `OUTGOING`, can be of `OUTGOING` or `INCOMING`\n* `resolution` : default resolution is `Day`\n* `timezone` : default timezone is `UTC`\n* `root`: The time tree root to be used (default to the default TimeTreeRoot)\n\n#### Retrieving events from the time tree\n\nThe most usage of the timetree is retrieving events from it. For finding events that occured at a specific time, you can use the `events.single` procedure call :\n\n```\nCALL ga.timetree.events.single({time: 1463659567468}) YIELD node RETURN node\n```\n\n![GraphAware TimeTree procedure events retrieve](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure4.png)\n\nThe procedure yield more than the node. The relationship type as well as the direction between the event and the time instant can also be returned :\n\n```\nCALL ga.timetree.events.single({time: 1463659567468}) YIELD node, relationshipType, direction RETURN *\n```\n\n![GraphAware TimeTree procedure single and yield all](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure5.png)\n\nThe following parameters can be passed in the map :\n\n* `time`: (mandatory) the long representation of the time\n* `relationshipTypes`: a List of relationshipType names that for constraining the search\n* `direction`: default to `OUTGOING`, can be of `OUTGOING` or `INCOMING`\n* `resolution` : default resolution is `Day`\n* `timezone` : default timezone is `UTC`\n* `root`: The time tree root to be used (default to the default TimeTreeRoot)\n\nAs for the time instants, you can also retrieve events for a range in time :\n\n```\nCALL ga.timetree.events.range({start: 1463659567468, end: 1463859569504}) YIELD node, relationshipType, direction RETURN *\n```\n\n![GraphAware TimeTree procedure retrieve in range](https://github.com/graphaware/neo4j-timetree/raw/master/docs/procedure6.png)\n\nThe same parameters from the `events.single` call apply for the `range` call, except `time` of course.\n\n### REST API\n\nWhen deployed in server mode, there are the following URLs that you can issue `GET` requests to:\n\n* `http://your-server-address:7474/graphaware/timetree/single/{time}` to get a node representing a time instant, where time must be replaced by a `long` number representing the number of milliseconds since 1/1/1970. The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/single/{time}/events` to get events attached to a time instant, where time must be replaced by a `long` number representing the number of milliseconds since 1/1/1970. The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/range/{startTime}/{endTime}` to get nodes representing time instants between {startTime} and {endTime} (inclusive). The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/range/{startTime}/{endTime}/events` to get events that occurred between {startTime} and {endTime} (inclusive). The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/now` to get a node representing now. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/single/{time}` to get a node representing a time instant, where {time} must be replaced by a `long` number representing the number of milliseconds since 1/1/1970 and {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/single/{time}/events` to get events attached to a time instant, where {time} must be replaced by a `long` number representing the number of milliseconds since 1/1/1970 and {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/range/{startTime}/{endTime}/events` to get events that occurred between {startTime} and {endTime} (inclusive) and {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/now` to get a node representing now, where {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n\nAdditionally, you can issue `POST` requests to:\n\n* `http://your-server-address:7474/graphaware/timetree/single/{time}` to get or create a node representing a time instant, where time must be replaced by a `long` number representing the number of milliseconds since 1/1/1970. The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/range/{startTime}/{endTime}` to get or create nodes representing time instants between {startTime} and {endTime} (inclusive). The default resolution is Day and the default time zone is UTC\n* `http://your-server-address:7474/graphaware/timetree/now` to get or create  a node representing now. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/single/{time}` to get or create  a node representing a time instant, where {time} must be replaced by a `long` number representing the number of milliseconds since 1/1/1970 and {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/now` to get or create a node representing now, where {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root. Defaults are the same as above.\n\nYou have four query parameters:\n\n* `resolution`, which can take on the following values:\n    * `Year`\n    * `Month`\n    * `Day`\n    * `Hour`\n    * `Minute`\n    * `Second`\n    * `Millisecond`\n* `timezone`, which can be a String representation of any `java.util.TimeZone`\n* `relationshipTypes`, which is a String representation of the `RelationshipType`s, one of which relate the event to a time instant, separated by a comma.\nThe default is all relationships, which is useful if you have different kinds of events occurring at the same time instant,\n  and related to the time instant with different relationship types. Here the default will give you all events that occurred at that time instant.\n\n  For instance, issuing the following request, asking for the hour node representing 5th April 2014 1pm (UTC time) in the\n  GMT+1 time zone\n\n      GET http://your-server-address:7474/graphaware/timetree/single/1396706182123?resolution=Hour\u0026timezone=GMT%2B1\n\n  on an empty database will result in the following graph being generated. The response body will contain the Neo4j node\n  of the node representing the hour. You can then use it in order to link to it. Example response:\n```json\n{\n  \"id\": 4,\n  \"properties\": {\n    \"value\": 14\n  },\n  \"labels\": [\n    \"Hour\"\n  ]\n}\n```\n* `direction`, which is a String representation of the `Direction`, with which the event is related to the time instant from the time instant's point of view. Defaults to `INCOMING`. Permitted values are `INCOMING`,`OUTGOING`,`BOTH`.\n\n![GraphAware TimeTree generated time tree](https://github.com/graphaware/neo4j-timetree/raw/master/docs/image4.jpg)\n\nThe response to calls returning events contain a list of events with relationship names attaching these to instants, e.g.:\n\n```json\n[\n  {\n    \"node\": {\n      \"id\": 99,\n      \"properties\": {\n        \"name\": \"eventA\"\n      },\n      \"labels\": [\"Event\"]\n    },\n    \"relationshipType\": \"STARTED_ON_DAY\",\n    \"direction\": \"INCOMING\"\n  },\n  {\n    \"node\": {\n      \"id\": 100,\n      \"properties\": {\n        \"name\": \"eventB\"\n      },\n      \"labels\": [\"Event\"]\n    },\n    \"relationshipType\": \"ENDED_ON_DAY\",\n    \"direction\": \"INCOMING\"\n  }\n]\n```\n\nAttaching an event to a time instant requires a POST request to:\n\n* `http://your-server-address:7474/graphaware/timetree/single/event` to attach an existing event node to a node representing a time instant.\n* `http://your-server-address:7474/graphaware/timetree/{rootNodeId}/single/event` to attach an existing event node to a node representing a time instant, where {rootNodeId} must be replaced by the ID of an existing node that should serve as the tree root\n\nThe POST body resembles:\n\n```json\n{\n  \"node\": {\n    \"id\": 99\n  },\n  \"relationshipType\": \"HAS_EVENT\",\n  \"direction\":\"INCOMING\",\n  \"timezone\": \"UTC\",\n  \"resolution\": \"DAY\",\n  \"time\": 1403506278000\n}\n```\n\nwhere\n\n* `node.id` is the node ID of an existing event node\n* `relationshipType` is the name of the relationship type that should be used to attach the event to the time instant.\n* `direction` (optional) is the name of the direction (`INCOMING` or `OUTGOING`) that should be used to attach the event to the time instant, *from the tree's point of view*. By default, it is `INCOMING`, i.e., the relationship is directed from the event to the time instant.\n* `timezone` is a String representation of any `java.util.TimeZone` (optional)\n* `resolution` as described above (optional)\n* `time` is a number representing the number of milliseconds since 1/1/1970\n\nIt is also possible to attach a brand new event that does not exist yet. In this case, specify `node.labels` and `node.properties`\ninstead if `node.id`. the body of the POST should resemble:\n\n```json\n{\n  \"node\": {\n    \"properties\": {\n      \"name\": \"eventA\"\n    },\n    \"labels\": [\"Event\"]\n  },\n  \"relationshipType\": \"HAS_EVENT\",\n  \"direction\": \"INCOMING\",\n  \"timezone\": \"UTC\",\n  \"resolution\": \"DAY\",\n  \"time\": 1403506278000\n}\n```\n\n### Automatic Event Attachment\n\nAll TimeTree versions compatible with Neo4j 2.2.0+ have the capability of automatically attaching events to the tree.\n\nBy default, any node created with label `Event` that contains a property named `timestamp` (with value as a `long` representing the timestamp in milliseconds),\nwill be attached to the tree with an outgoing relationship `AT_TIME` from the event node to tree.\n\nRequired configuration as well as overriding the defaults are specified in `neo4j.conf` as follows:\n\n```\n#For the framework to work at all, you need this\ndbms.unmanaged_extension_classes=com.graphaware.server=/graphaware\n\n# Runtime must be enabled like this\ncom.graphaware.runtime.enabled=true\n\n# A Runtime module that takes care of attaching the events like this (TT is the ID of the module)\ncom.graphaware.module.TT.1=com.graphaware.module.timetree.module.TimeTreeModuleBootstrapper\n\n# autoAttach must be set to true\ncom.graphaware.module.TT.autoAttach=true\n\n# Optionally, nodes which represent events and should be attached automatically have to be defined (defaults to nodes with label Event)\ncom.graphaware.module.TT.event=hasLabel('Email')\n\n# Optionally, a property on the event nodes that represents the the time (long) at which the event took place must be specified (defaults to \"timestamp\")\ncom.graphaware.module.TT.timestamp=time\n\n# Optionally, a property on the event nodes that represents the node ID (long) of the root node for the tree, to which the event should be attached (defaults to \"timeTreeRootId\")\ncom.graphaware.module.TT.customTimeTreeRootProperty=rootId\n\n# Optionally, a resolution can be specified (defaults to DAY)\ncom.graphaware.module.TT.resolution=HOUR\n\n# Optionally, a time zone can be specified (defaults to UTC)\ncom.graphaware.module.TT.timezone=GMT+1\n\n# Optionally, a relationship type with which the events will be attached to the tree can be specified (defaults to AT_TIME)\ncom.graphaware.module.TT.relationship=SENT_ON\n\n# Optionally, a relationship direction (from the tree's point of view), with which the events will be attached to the tree can be specified (defaults to INCOMING)\ncom.graphaware.module.TT.direction=INCOMING\n\n```\n\nFor more information on the `com.graphaware.module.TT.event` setting, i.e. how to write expressions that define which\nnodes should be attached to the tree, please refer to [Inclusion Policies](https://github.com/graphaware/neo4j-framework/tree/master/common#inclusion-policies).\n\nExamples of relevant expressions that can be used:\n\n* `hasProperty('propertyName')` - returns boolean. Example: `hasProperty('name')`\n* `getProperty('propertyName','defaultValue')` - returns Object. Example: `getProperty('name','unknown') == 'Michal'`\n* `getDegree()` or `degree` - returns int. Examples: `degree \u003e 1`\n* `getDegree('typeOrDirection')` - returns int. Examples: `getDegree('OUTGOING') == 0` or `getDegree('FRIEND_OF') \u003e 1000`\n* `getDegree('type', 'direction')` - returns int. Examples: `getDegree('FRIEND_OF','OUTGOING') \u003e 0`\n* `hasLabel('label')` - returns boolean. Example: `hasLabel('Person')`\n\nOf course, the expressions can be combined with logical operators, for instance:\n* `hasLabel('Event') || hasProperty('startDate') || getProperty('significance', 0) \u003e 20`\n\nBy default, events are attached to a single tree, unless the events have a `timeTreeRootId` (or its equivalent changed in config) property, in\n which case a tree rooted at the node with the specified ID will be used to attach the event.\n\nNote that you can define multiple modules if desired, e.g.:\n```\ncom.graphaware.runtime.enabled=true\n\ncom.graphaware.module.TT.1=com.graphaware.module.timetree.module.TimeTreeModuleBootstrapper\ncom.graphaware.module.TT.event=hasProperty('timestamp_enabled')\ncom.graphaware.module.TT.relationship=ENABLED_ON\ncom.graphaware.module.TT.autoAttach=true\ncom.graphaware.module.TT.timestamp=timestamp_enabled\n\ncom.graphaware.module.TS.2=com.graphaware.module.timetree.module.TimeTreeModuleBootstrapper\ncom.graphaware.module.TS.event=hasProperty('timestamp_disabled')\ncom.graphaware.module.TS.relationship=DISABLED_ON\ncom.graphaware.module.TS.autoAttach=true\ncom.graphaware.module.TS.timestamp=timestamp_disabled\n\n...\n```\n\n### Java API\n\nJava API has the same functionality as the rest API. Please refer to \u003ca href=\"http://graphaware.com/site/timetree/latest/apidocs/\" target=\"_blank\"\u003eits Javadoc\u003c/a\u003e (look at the `TimeTree` and `TimedEvents` interfaces).\n\nLicense\n-------\n\nCopyright (c) 2013-2020 GraphAware\n\nGraphAware is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License\nas published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied\nwarranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\nYou should have received a copy of the GNU General Public License along with this program.\nIf not, see \u003chttp://www.gnu.org/licenses/\u003e.\n","funding_links":[],"categories":["Java","Extensions","java","REST API"],"sub_categories":["REST API","Other"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgraphaware%2Fneo4j-timetree","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgraphaware%2Fneo4j-timetree","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgraphaware%2Fneo4j-timetree/lists"}