Unobtrusive login

stepik-java-api/src/main/java/org/stepik/api/actions/StepikStepiksAction.java

@@ -2,6 +2,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.stepik.api.client.StepikApiClient;
+import org.stepik.api.objects.users.User;
 import org.stepik.api.queries.stepiks.StepikStepiksGetQuery;
 
 /**
@@ -16,4 +17,10 @@ public StepikStepiksAction(@NotNull StepikApiClient stepikApiClient) {
     public StepikStepiksGetQuery get() {
         return new StepikStepiksGetQuery(this);
     }
+
+    public User getCurrentUser() {
+        return this.get()
+                .id(1)
+                .execute().getUser();
+    }
 }

stepik-java-api/src/main/java/org/stepik/api/objects/metrics/Metric.java

@@ -11,7 +11,7 @@
  */
 public class Metric {
     private String name;
-    private Integer timestamp;
+    private Long timestamp;
     private Map<String, String> tags;
     private Map<String, Object> data;
 
@@ -57,11 +57,11 @@ public void setName(@Nullable String name) {
     }
 
     @Nullable
-    public Integer getTimestamp() {
+    public Long getTimestamp() {
         return timestamp;
     }
 
-    public void setTimestamp(@Nullable Integer timestamp) {
+    public void setTimestamp(@Nullable Long timestamp) {
         this.timestamp = timestamp;
     }
 }

stepik-java-api/src/main/java/org/stepik/api/queries/metrics/StepikMetricsPostQuery.java

@@ -26,7 +26,7 @@ public StepikMetricsPostQuery name(@NotNull String name) {
     }
 
     @NotNull
-    public StepikMetricsPostQuery timestamp(int value) {
+    public StepikMetricsPostQuery timestamp(long value) {
         metrics.getMetric().setTimestamp(value);
         return this;
     }

stepik-union/src/main/java/org/stepik/core/StepikProjectManager.java

@@ -2,12 +2,15 @@
 
 import com.google.gson.internal.LinkedTreeMap;
 import com.intellij.ide.projectView.ProjectView;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.fileEditor.FileEditorManager;
 import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleWithNameAlreadyExists;
@@ -17,6 +20,8 @@
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.thoughtworks.xstream.XStream;
@@ -29,6 +34,7 @@
 import org.jdom.output.XMLOutputter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.stepik.api.client.StepikApiClient;
 import org.stepik.api.objects.StudyObject;
 import org.stepik.api.objects.courses.Course;
 import org.stepik.api.objects.lessons.CompoundUnitLesson;
@@ -48,6 +54,9 @@
 import org.stepik.core.serialization.StudySerializationUtils;
 import org.stepik.core.serialization.StudyUnrecognizedFormatException;
 import org.stepik.core.serialization.SupportedLanguagesConverter;
+import org.stepik.core.stepik.StepikAuthManager;
+import org.stepik.core.stepik.StepikAuthManagerListener;
+import org.stepik.core.stepik.StepikAuthState;
 import org.stepik.core.ui.StudyToolWindow;
 import org.stepik.plugin.projectWizard.idea.SandboxModuleBuilder;
 import org.w3c.dom.Document;
@@ -61,12 +70,19 @@
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.stepik.core.stepik.StepikAuthManager.authAndGetStepikApiClient;
+import static org.stepik.core.stepik.StepikAuthManager.isAuthenticated;
+import static org.stepik.core.stepik.StepikAuthState.AUTH;
+import static org.stepik.core.stepik.StepikAuthState.NOT_AUTH;
+import static org.stepik.core.stepik.StepikAuthState.SHOW_DIALOG;
 import static org.stepik.core.utils.ProjectFilesUtils.getOrCreateSrcDirectory;
 
 @State(name = "StepikStudySettings", storages = @Storage("stepik_study_project.xml"))
-public class StepikProjectManager implements PersistentStateComponent<Element>, DumbAware {
+public class StepikProjectManager implements PersistentStateComponent<Element>, DumbAware, StepikAuthManagerListener, Disposable {
     private static final int CURRENT_VERSION = 4;
     private static final Logger logger = Logger.getInstance(StepikProjectManager.class);
     @XStreamOmitField
@@ -81,6 +97,9 @@ public class StepikProjectManager implements PersistentStateComponent<Element>,
     private static DOMBuilder domBuilder;
     @XStreamOmitField
     private final Project project;
+    @XStreamOmitField
+    private final ExecutorService executor = Executors.newSingleThreadExecutor();
+    @Nullable
     private StudyNode<?, ?> root;
     private StudyNode<?, ?> selected;
     private boolean showHint = false;
@@ -91,6 +110,10 @@ public class StepikProjectManager implements PersistentStateComponent<Element>,
 
     public StepikProjectManager(@Nullable Project project) {
         this.project = project;
+        StepikAuthManager.addListener(this);
+        if (project != null) {
+            Disposer.register(project, this);
+        }
     }
 
     public StepikProjectManager() {
@@ -216,8 +239,32 @@ public static boolean isAdaptive(Project project) {
         return instance != null && instance.isAdaptive();
     }
 
+    public static void updateAdaptiveSelected(@Nullable Project project) {
+        if (project == null) {
+            return;
+        }
+        StepikProjectManager instance = getInstance(project);
+        if (instance != null) {
+            instance.updateAdaptiveSelected();
+        }
+    }
+
+    private void updateAdaptiveSelected() {
+        if (isAdaptive() && root != null) {
+            StudyNode<?, ?> recommendation = StudyUtils.getRecommendation(root);
+            if (selected == null || (recommendation != null && selected.getParent() != recommendation.getParent())) {
+                ApplicationManager.getApplication().invokeAndWait(() -> {
+                    for (VirtualFile file : FileEditorManager.getInstance(project).getOpenFiles()) {
+                        FileEditorManager.getInstance(project).closeFile(file);
+                    }
+                });
+                setSelected(recommendation);
+            }
+        }
+    }
+
     @Nullable
-    public StudyNode<?, ?> getSelected() {
+    private StudyNode<?, ?> getSelected() {
         return selected;
     }
 
@@ -242,7 +289,7 @@ public void setSelected(@Nullable StudyNode<?, ?> selected, boolean force) {
         }
     }
 
-    public void updateSelection() {
+    private void updateSelection() {
         setSelected(selected, true);
     }
 
@@ -300,56 +347,72 @@ public void loadState(Element state) {
         }
     }
 
-    public boolean isAdaptive() {
+    private boolean isAdaptive() {
+        if (root == null) {
+            return false;
+        }
         StudyObject data = root.getData();
         return data != null && data.isAdaptive();
     }
 
     private void refreshCourse() {
-        if (getProjectRoot() == null || project == null) {
+        if (project == null || root == null) {
             return;
         }
 
         root.setProject(project);
 
-        new Thread(() -> {
-            root.reloadData(project);
-            ProgressManager.getInstance().run(new Task.Backgroundable(project, "Synchronize project") {
+        executor.execute(() -> {
+            StepikApiClient stepikApiClient = authAndGetStepikApiClient();
+            if (isAuthenticated()) {
+                root.reloadData(project, stepikApiClient);
+            }
+            ProgressManager.getInstance().run(new Task.Backgroundable(project, "Synchronize Project") {
                 @Override
                 public void run(@NotNull ProgressIndicator indicator) {
-                    repairProjectFiles(root);
                     if (project.isDisposed()) {
                         return;
                     }
+
+                    repairProjectFiles(root);
+                    repairSandbox();
+
+                    ApplicationManager.getApplication().invokeLater(() -> {
+                                VirtualFileManager.getInstance().syncRefresh();
+                                setSelected(selected, false);
+                            }
+                    );
+                }
+
+                private void repairSandbox() {
                     VirtualFile projectDir = project.getBaseDir();
                     if (projectDir != null && projectDir.findChild(EduNames.SANDBOX_DIR) == null) {
-                        ModifiableModuleModel model = ModuleManager.getInstance(project)
-                                .getModifiableModel();
-
-                        ApplicationManager.getApplication().runWriteAction(() -> {
-                            try {
-                                new SandboxModuleBuilder(projectDir.getPath()).createModule(model);
-                                model.commit();
-                            } catch (IOException | ConfigurationException | JDOMException | ModuleWithNameAlreadyExists e) {
-                                logger.warn("Failed repair Sandbox", e);
-                            }
-                        });
+                        Application application = ApplicationManager.getApplication();
+
+                        ModifiableModuleModel model = application.runReadAction(
+                                (Computable<ModifiableModuleModel>) () -> ModuleManager.getInstance(project)
+                                        .getModifiableModel());
+
+
+                        application.invokeLater(() ->
+                                application.runWriteAction(() -> {
+                                    try {
+                                        new SandboxModuleBuilder(projectDir.getPath()).createModule(model);
+                                        model.commit();
+                                    } catch (IOException | ConfigurationException | JDOMException | ModuleWithNameAlreadyExists e) {
+                                        logger.warn("Failed repair Sandbox", e);
+                                    }
+                                })
+                        );
                     }
-
-                    ApplicationManager.getApplication().invokeLater(() ->
-                            VirtualFileManager.getInstance().syncRefresh()
-                    );
                 }
             });
-        }).start();
+        });
     }
 
     private void repairProjectFiles(@NotNull StudyNode<?, ?> node) {
         if (project != null) {
             if (node instanceof StepNode) {
-                if (project.isDisposed()) {
-                    return;
-                }
                 ApplicationManager.getApplication().invokeAndWait(() -> {
                     if (project.isDisposed()) {
                         return;
@@ -431,4 +494,28 @@ public int hashCode() {
         result = 31 * result + (uuid != null ? uuid.hashCode() : 0);
         return result;
     }
+
+    @Override
+    public void stateChanged(@NotNull StepikAuthState oldState, @NotNull StepikAuthState newState) {
+        if (newState == NOT_AUTH || newState == AUTH) {
+            if (root != null) {
+                root.resetStatus();
+                if (newState == AUTH) {
+                    refreshCourse();
+                }
+            }
+
+            if (oldState == SHOW_DIALOG && newState == NOT_AUTH) {
+                setSelected(selected, false);
+            } else {
+                updateSelection();
+            }
+        }
+    }
+
+    @Override
+    public void dispose() {
+        StepikAuthManager.removeListener(this);
+        executor.shutdown();
+    }
 }

stepik-union/src/main/java/org/stepik/core/StudyProjectComponent.java

@@ -13,6 +13,7 @@
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.DumbAwareRunnable;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.openapi.wm.ToolWindowAnchor;
@@ -21,11 +22,9 @@
 import javafx.application.Platform;
 import org.jetbrains.annotations.NotNull;
 import org.stepik.core.actions.StudyActionWithShortcut;
-import org.stepik.core.courseFormat.StudyNode;
 import org.stepik.core.metrics.Metrics;
 import org.stepik.core.ui.StudyToolWindow;
 import org.stepik.core.ui.StudyToolWindowFactory;
-import org.stepik.plugin.actions.navigation.StudyNavigator;
 
 import javax.swing.*;
 import java.util.ArrayList;
@@ -72,6 +71,10 @@ public void projectOpened() {
                             registerShortcuts();
                         }));
         Metrics.openProject(project, SUCCESSFUL);
+
+        StartupManager.getInstance(project).runWhenProjectIsInitialized(() ->
+                executor.execute(() -> StepikProjectManager.updateAdaptiveSelected(project)
+                ));
     }
 
     public void registerStudyToolWindow() {
@@ -86,33 +89,6 @@ public void registerStudyToolWindow() {
             studyToolWindow.show(null);
             StudyUtils.initToolWindows(project);
         }
-
-        executor.execute(() -> {
-            StepikProjectManager projectManager = StepikProjectManager.getInstance(project);
-            if (projectManager == null) {
-                return;
-            }
-
-            StudyNode root = projectManager.getProjectRoot();
-
-            StudyNode<?, ?> selected = projectManager.getSelected();
-            if (root != null) {
-                if (projectManager.isAdaptive()) {
-                    StudyNode<?, ?> recommendation = StudyUtils.getRecommendation(root);
-                    if (recommendation == null) {
-                        selected = null;
-                    } else if (selected == null || selected.getParent() != recommendation.getParent()) {
-                        selected = recommendation;
-                    }
-                }
-
-                if (selected == null) {
-                    selected = StudyNavigator.nextLeaf(root);
-                }
-
-                projectManager.setSelected(selected);
-            }
-        });
     }
 
     private void registerShortcuts() {