File context menu

database/api/src/main/java/com/neueda/jetbrains/plugin/graphdb/database/api/GraphDatabaseApi.java

@@ -2,11 +2,14 @@
 
 import com.neueda.jetbrains.plugin.graphdb.database.api.query.GraphQueryResult;
 
+import java.util.List;
 import java.util.Map;
 
 public interface GraphDatabaseApi {
 
     GraphQueryResult execute(String query);
 
     GraphQueryResult execute(String query, Map<String, Object> statementParameters);
+
+    GraphQueryResult executeBatch(List<String> query, Map<String, Object> statementParameters);
 }

database/neo4j/src/main/java/com/neueda/jetbrains/plugin/graphdb/database/neo4j/bolt/Neo4jBoltDatabase.java

@@ -12,6 +12,7 @@
 import org.neo4j.driver.v1.StatementResult;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -47,7 +48,7 @@ public GraphQueryResult execute(String query) {
     @Override
     public GraphQueryResult execute(String query, Map<String, Object> statementParameters) {
         try (Driver driver = GraphDatabase.driver(url, auth);
-            Session session = driver.session()) {
+             Session session = driver.session()) {
 
             Neo4jBoltBuffer buffer = new Neo4jBoltBuffer();
 
@@ -65,4 +66,21 @@ public GraphQueryResult execute(String query, Map<String, Object> statementParam
             return new Neo4jBoltQueryResult(endTime - startTime, buffer);
         }
     }
+
+    @Override
+    public GraphQueryResult executeBatch(List<String> queries, Map<String, Object> statementParameters) {
+        try (Driver driver = GraphDatabase.driver(url, auth);
+             Session session = driver.session()) {
+
+            Neo4jBoltBuffer buffer = new Neo4jBoltBuffer();
+
+            long startTime = System.currentTimeMillis();
+            for (String query : queries) {
+                session.run(query, statementParameters).consume();
+            }
+            long endTime = System.currentTimeMillis();
+
+            return new Neo4jBoltQueryResult(endTime - startTime, buffer);
+        }
+    }
 }

graph-database-support-plugin/src/main/resources/META-INF/plugin.xml

@@ -215,5 +215,16 @@
                     description="Clean canvas">
             </action>
         </group>
+
+        <group id="GraphDatabaseFileActions"
+               text="Graph Database File Actions" description="Graph Database File Actions"
+               icon="/graphdb/icons/window/graph_13x13.png" popup="true">
+            <action id="GraphDatabaseFileActions.ExecuteAll"
+                    class="com.neueda.jetbrains.plugin.graphdb.jetbrains.actions.execute.ExecuteAllAction"
+                    text="Execute All"
+                    icon="/general/run.png">
+            </action>
+            <add-to-group group-id="ProjectViewPopupMenu"/>
+        </group>
     </actions>
 </idea-plugin>

testing/integration-neo4j/build.gradle

@@ -9,6 +9,7 @@ dependencies {
     testCompile project(':testing:database:neo4j-common')
     testCompile 'org.xeustechnologies:jcl-core:2.8'
     testCompile "org.assertj:assertj-core:$versionAssertj"
+    testCompile "org.mockito:mockito-core:$versionMockito"
 }
 
 test {

testing/integration-neo4j/src/test/java/com/neueda/jetbrains/plugin/graphdb/test/integration/neo4j/tests/jetbrains/StatementCollectorTest.java

@@ -0,0 +1,139 @@
+package com.neueda.jetbrains.plugin.graphdb.test.integration.neo4j.tests.jetbrains;
+
+import com.intellij.psi.PsiFile;
+import com.intellij.util.messages.MessageBus;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.actions.execute.StatementCollector;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.event.QueryParametersRetrievalErrorEvent;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.params.ParametersService;
+import com.neueda.jetbrains.plugin.graphdb.test.integration.neo4j.tests.cypher.util.BaseGenericTest;
+import org.mockito.Mockito;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class StatementCollectorTest extends BaseGenericTest {
+
+    private static final String EMPTY_PARAMETERS = "{}";
+    private static final String PARAMETERS = "{\"name\": \"Andrew\"}";
+    private static final String WRONG_PARAMETERS = "{wrong json}";
+    private StatementCollector statementCollector;
+    private ParametersService parametersService;
+    private MessageBus messageBusMock;
+    private QueryParametersRetrievalErrorEvent eventMock;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        messageBusMock = Mockito.mock(MessageBus.class);
+        eventMock = Mockito.mock(QueryParametersRetrievalErrorEvent.class);
+        when(messageBusMock.syncPublisher(any())).thenReturn(eventMock);
+
+        parametersService = new ParametersService();
+        statementCollector = new StatementCollector(messageBusMock, parametersService);
+    }
+
+    public void testSingleQuery() {
+        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN n;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isFalse();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .containsExactly("MATCH (n) RETURN n;");
+    }
+
+    public void testMultipleQueriesInOneLine() {
+        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN n;MATCH (m) RETURN m;");
+        psiFile.acceptChildren(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isFalse();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .containsExactly("MATCH (n) RETURN n;", "MATCH (m) RETURN m;");
+    }
+
+    public void testOneQueryWithError() {
+        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH () ETURN n;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isTrue();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .isEmpty();
+    }
+
+    public void testMultipleQueriesInDifferentLinesWithError() {
+        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN *;\nMATCH () ETURN n;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isTrue();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .isEmpty();
+    }
+
+    public void testMultipleCorrectQueriesInDifferentLines() {
+        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN *;\nMATCH (m) RETURN m;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isFalse();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .containsExactly("MATCH (n) RETURN *;", "MATCH (m) RETURN m;");
+    }
+
+    public void testMultipleCorrectQueriesInDifferentLinesWithParameters() {
+        parametersService.registerParametersProvider(() -> PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "CREATE (n {name: $name});\nMATCH (m) RETURN m;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(0)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isFalse();
+        assertThat(statementCollector.getParameters())
+            .containsValues("Andrew");
+        assertThat(statementCollector.getQueries())
+            .containsExactly("CREATE (n {name: $name});", "MATCH (m) RETURN m;");
+    }
+
+    public void testParameterExtractionErrorOccurs() {
+        parametersService.registerParametersProvider(() -> WRONG_PARAMETERS);
+        PsiFile psiFile = myFixture.configureByText("test.cyp", "CREATE (n {name: $name});\nMATCH (m) RETURN m;");
+        psiFile.accept(statementCollector);
+
+        verify(eventMock, times(1)).handleError(any(), any());
+
+        assertThat(statementCollector.hasErrors())
+            .isTrue();
+        assertThat(statementCollector.getParameters())
+            .isEmpty();
+        assertThat(statementCollector.getQueries())
+            .isEmpty();
+    }
+}

ui/jetbrains/src/main/java/com/neueda/jetbrains/plugin/graphdb/jetbrains/actions/execute/ExecuteAllAction.java

@@ -0,0 +1,56 @@
+package com.neueda.jetbrains.plugin.graphdb.jetbrains.actions.execute;
+
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.CommonDataKeys;
+import com.intellij.openapi.actionSystem.PlatformDataKeys;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.ui.popup.ListPopup;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.messages.MessageBus;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.component.datasource.DataSourcesComponent;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.ConsoleToolWindow;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.params.ParametersService;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.util.Notifier;
+import com.neueda.jetbrains.plugin.graphdb.language.cypher.file.CypherFileType;
+
+public class ExecuteAllAction extends AnAction {
+    @Override
+    public void update(AnActionEvent e) {
+        if (e.getDataContext().getData(PlatformDataKeys.PSI_FILE).getFileType() instanceof CypherFileType) {
+            e.getPresentation().setEnabled(true);
+        } else {
+            e.getPresentation().setEnabled(false);
+        }
+    }
+    @Override
+    public void actionPerformed(AnActionEvent e) {
+        Project project = getEventProject(e);
+        MessageBus messageBus = project.getMessageBus();
+        ParametersService parameterService = ServiceManager.getService(project, ParametersService.class);
+        PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
+
+        StatementCollector statementCollector = new StatementCollector(messageBus, parameterService);
+        psiFile.acceptChildren(statementCollector);
+        if (!statementCollector.hasErrors()) {
+            ExecuteQueryPayload executeQueryPayload =
+                new ExecuteQueryPayload(statementCollector.getQueries(), statementCollector.getParameters(), psiFile.getName());
+            ConsoleToolWindow.ensureOpen(project);
+
+            DataSourcesComponent dataSourcesComponent = project.getComponent(DataSourcesComponent.class);
+            ListPopup popup = JBPopupFactory.getInstance().createActionGroupPopup(
+                "Choose Data Source",
+                new ChooseDataSourceActionGroup(messageBus, dataSourcesComponent, executeQueryPayload),
+                e.getDataContext(),
+                JBPopupFactory.ActionSelectionAid.SPEEDSEARCH,
+                false
+            );
+            popup.showInBestPositionFor(e.getDataContext());
+        } else {
+            System.out.println("NOTIFY");
+            Notifier.error("Query execution error", "File contains errors");
+        }
+    }
+}

ui/jetbrains/src/main/java/com/neueda/jetbrains/plugin/graphdb/jetbrains/actions/execute/ExecuteQueryPayload.java

@@ -4,32 +4,48 @@
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
 public class ExecuteQueryPayload {
 
-    private final String content;
+    private final List<String> queries;
 
     private final Map<String, Object> parameters;
 
     private final Editor editor;
 
+    private final String fileName;
+
     public ExecuteQueryPayload(String content) {
-        this.content = content;
+        this.queries = Collections.singletonList(content);
         this.editor = null;
         this.parameters = Collections.emptyMap();
+        this.fileName = null;
+    }
+
+    public ExecuteQueryPayload(List<String> queries, Map<String, Object> parameters, String fileName) {
+        this.queries = queries;
+        this.parameters = parameters;
+        this.editor = null;
+        this.fileName = fileName;
     }
 
     public ExecuteQueryPayload(String content, Map<String, Object> parameters, Editor editor) {
-        this.content = content;
+        this.queries = Collections.singletonList(content);
         this.parameters = parameters;
         this.editor = editor;
+        this.fileName = null;
     }
 
     @NotNull
-    public String getContent() {
-        return content;
+    public List<String> getQueries() {
+        return queries;
+    }
+
+    public Optional<String> getFileName() {
+        return Optional.ofNullable(fileName);
     }
 
     public Map<String, Object> getParameters() {