View Javadoc

    1   /**
    2    * Copyright (c) 2002-2011 "Neo Technology,"
    3    * Network Engine for Objects in Lund AB [http://neotechnology.com]
    4    *
    5    * This file is part of Neo4j.
    6    *
    7    * Neo4j is free software: you can redistribute it and/or modify
    8    * it under the terms of the GNU General Public License as published by
    9    * the Free Software Foundation, either version 3 of the License, or
    10   * (at your option) any later version.
    11   *
    12   * This program is distributed in the hope that it will be useful,
    13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15   * GNU General Public License for more details.
    16   *
    17   * You should have received a copy of the GNU General Public License
    18   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    19   */
    20  package org.neo4j.server.plugins;
    21
    22  import org.neo4j.graphalgo.GraphAlgoFactory;
    23  import org.neo4j.graphalgo.PathFinder;
    24  import org.neo4j.graphdb.GraphDatabaseService;
    25  import org.neo4j.graphdb.Node;
    26  import org.neo4j.graphdb.Path;
    27  import org.neo4j.graphdb.Relationship;
    28  import org.neo4j.graphdb.RelationshipType;
    29  import org.neo4j.graphdb.Transaction;
    30  import org.neo4j.helpers.Predicate;
    31  import org.neo4j.helpers.collection.FilteringIterable;
    32  import org.neo4j.kernel.Traversal;
    33
    34  import java.util.ArrayList;
    35  import java.util.Arrays;
    36  import java.util.List;
    37  import java.util.Set;
    38
    39  @Description( "Here you can describe your plugin. It will show up in the description of the methods." )
    40  public class Plugin extends ServerPlugin
    41  {
    42      public static final String GET_REFERENCE_NODE = "reference_node_uri";
    43      public static final String GET_CONNECTED_NODES = "connected_nodes";
    44      static String _string;
    45      static Byte _byte;
    46      static Character _character;
    47      static Integer _integer;
    48      static Short _short;
    49      static Long _long;
    50      static Float _float;
    51      static Double _double;
    52      static Boolean _boolean;
    53      static Long optional;
    54      static Set<String> stringSet;
    55      static List<String> stringList;
    56      static String[] stringArray;
    57      public static int[] intArray;
    58
    59      @Description( "Get the reference node from the graph database" )
    60      @PluginTarget( GraphDatabaseService.class )
    61      @Name( GET_REFERENCE_NODE )
    62      public Node getReferenceNode( @Source GraphDatabaseService graphDb )
    63      {
    64          return graphDb.getReferenceNode();
    65      }
    66
    67      @Name( GET_CONNECTED_NODES )
    68      @PluginTarget( Node.class )
    69      public Iterable<Node> getAllConnectedNodes( @Source Node start )
    70      {
    71          ArrayList<Node> nodes = new ArrayList<Node>();
    72
    73          for ( Relationship rel : start.getRelationships() )
    74          {
    75              nodes.add( rel.getOtherNode( start ) );
    76          }
    77
    78          return nodes;
    79      }
    80
    81      @PluginTarget( Node.class )
    82      public Iterable<Relationship> getRelationshipsBetween( final @Source Node start,
    83              final @Parameter( name = "other" ) Node end )
    84      {
    85          return new FilteringIterable<Relationship>( start.getRelationships(),
    86                  new Predicate<Relationship>()
    87                  {
    88                      @Override
    89                      public boolean accept( Relationship item )
    90                      {
    91                          return item.getOtherNode( start ).equals( end );
    92                      }
    93                  } );
    94      }
    95
    96      @PluginTarget( Node.class )
    97      public Iterable<Relationship> createRelationships( @Source Node start,
    98              @Parameter( name = "type" ) RelationshipType type,
    99              @Parameter( name = "nodes" ) Iterable<Node> nodes )
    100     {
    101         List<Relationship> result = new ArrayList<Relationship>();
    102         Transaction tx = start.getGraphDatabase().beginTx();
    103         try
    104         {
    105             for ( Node end : nodes )
    106             {
    107                 result.add( start.createRelationshipTo( end, type ) );
    108             }
    109             tx.success();
    110         }
    111         finally
    112         {
    113             tx.finish();
    114         }
    115         return result;
    116     }
    117
    118     @PluginTarget( Node.class )
    119     public Node getThisNodeOrById( @Source Node start, @Parameter( name = "id", optional = true ) Long id )
    120     {
    121         optional = id;
    122
    123         if ( id == null )
    124         {
    125             return start;
    126         }
    127
    128         return start.getGraphDatabase().getNodeById( id );
    129     }
    130
    131     @PluginTarget( GraphDatabaseService.class )
    132     public Node methodWithIntParam(
    133             @Source GraphDatabaseService db,
    134             @Parameter( name = "id", optional = false ) int id )
    135     {
    136         return db.getNodeById( id );
    137     }
    138
    139     @PluginTarget( Relationship.class )
    140     public Iterable<Node> methodOnRelationship( @Source Relationship rel )
    141     {
    142         return Arrays.asList( rel.getNodes() );
    143     }
    144
    145     @PluginTarget( GraphDatabaseService.class )
    146     public Node methodWithAllParams(
    147             @Source GraphDatabaseService db,
    148             @Parameter( name = "id", optional = false ) String a,
    149             @Parameter( name = "id2", optional = false ) Byte b,
    150             @Parameter( name = "id3", optional = false ) Character c,
    151             @Parameter( name = "id4", optional = false ) Short d,
    152             @Parameter( name = "id5", optional = false ) Integer e,
    153             @Parameter( name = "id6", optional = false ) Long f,
    154             @Parameter( name = "id7", optional = false ) Float g,
    155             @Parameter( name = "id8", optional = false ) Double h,
    156             @Parameter( name = "id9", optional = false ) Boolean i )
    157     {
    158         _string = a;
    159         _byte = b;
    160         _character = c;
    161         _short = d;
    162         _integer = e;
    163         _long = f;
    164         _float = g;
    165         _double = h;
    166         _boolean = i;
    167
    168         return db.getReferenceNode();
    169     }
    170
    171     @PluginTarget( GraphDatabaseService.class )
    172     public Node methodWithSet( @Source GraphDatabaseService db,
    173             @Parameter( name = "strings", optional = false ) Set<String> params )
    174     {
    175         stringSet = params;
    176         return db.getReferenceNode();
    177     }
    178
    179     @PluginTarget( GraphDatabaseService.class )
    180     public Node methodWithList( @Source GraphDatabaseService db,
    181             @Parameter( name = "strings", optional = false ) List<String> params )
    182     {
    183         stringList = params;
    184         return db.getReferenceNode();
    185     }
    186
    187     @PluginTarget( GraphDatabaseService.class )
    188     public Node methodWithArray( @Source GraphDatabaseService db,
    189                                  @Parameter( name = "strings", optional = false ) String[] params )
    190     {
    191         stringArray = params;
    192         return db.getReferenceNode();
    193     }
    194
    195     @PluginTarget( GraphDatabaseService.class )
    196     public Node methodWithIntArray( @Source GraphDatabaseService db,
    197             @Parameter( name = "ints", optional = false ) int[] params )
    198     {
    199         intArray = params;
    200         return db.getReferenceNode();
    201     }
    202
    203     @PluginTarget( GraphDatabaseService.class )
    204     public Node methodWithOptionalArray( @Source GraphDatabaseService db,
    205             @Parameter( name = "ints", optional = true ) int[] params )
    206     {
    207         intArray = params;
    208         return db.getReferenceNode();
    209     }
    210
    211     @PluginTarget( Node.class )
    212     public Path pathToReference( @Source Node me )
    213     {
    214         PathFinder<Path> finder = GraphAlgoFactory.shortestPath( Traversal.expanderForAllTypes(), 6 );
    215         return finder.findSinglePath( me.getGraphDatabase().getReferenceNode(), me );
    216     }
    217 }