Merge pull request #19 from rage/listCourses

List courses

Author: samutamm

tmc-application/manifest.mf

@@ -4,3 +4,4 @@ OpenIDE-Module: fi.helsinki.cs.tmc.application
 OpenIDE-Module-Localizing-Bundle: fi/helsinki/cs/tmc/application/Bundle.properties
 OpenIDE-Module-Specification-Version: 1.0
 OpenIDE-Module-Install: fi/helsinki/cs/tmc/application/TmcAppModuleInstall.class
+OpenIDE-Module-Needs: org.openide.filesystems.FileUtil.toFileObject

tmc-plugin/src/fi/helsinki/cs/tmc/actions/CheckForNewExercisesOrUpdates.java

@@ -7,22 +7,25 @@
 import fi.helsinki.cs.tmc.model.CourseDb;
 import fi.helsinki.cs.tmc.model.LocalExerciseStatus;
 import fi.helsinki.cs.tmc.model.ObsoleteClientException;
-import fi.helsinki.cs.tmc.model.ServerAccess;
 import fi.helsinki.cs.tmc.model.NBTmcSettings;
+import fi.helsinki.cs.tmc.model.ServerAccess;
 import fi.helsinki.cs.tmc.model.TmcCoreSingleton;
 import fi.helsinki.cs.tmc.ui.DownloadOrUpdateExercisesDialog;
 import fi.helsinki.cs.tmc.ui.ConvenientDialogDisplayer;
 import fi.helsinki.cs.tmc.ui.TmcNotificationDisplayer;
 import fi.helsinki.cs.tmc.utilities.Inflector;
 import fi.helsinki.cs.tmc.utilities.TmcStringUtils;
 import hy.tmc.core.TmcCore;
+import hy.tmc.core.domain.Exercise;
 import hy.tmc.core.exceptions.TmcCoreException;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.util.ArrayList;
 import javax.swing.AbstractAction;
 import javax.swing.Icon;
 import org.apache.commons.lang3.StringUtils;
+import org.netbeans.api.progress.ProgressHandle;
+import org.netbeans.api.progress.ProgressHandleFactory;
 import org.openide.awt.ActionID;
 import org.openide.awt.ActionReference;
 import org.openide.awt.ActionReferences;
@@ -50,7 +53,6 @@ public static void startTimer() {
     private static final TmcNotificationDisplayer.SingletonToken notifierToken = TmcNotificationDisplayer.createSingletonToken();
 
     private CourseDb courseDb;
-    private ServerAccess serverAccess;
     private TmcNotificationDisplayer notifier;
     private ConvenientDialogDisplayer dialogs;
     private boolean beQuiet;
@@ -63,7 +65,6 @@ public CheckForNewExercisesOrUpdates() {
 
     public CheckForNewExercisesOrUpdates(boolean beQuiet, boolean backgroundCheck) {
         this.courseDb = CourseDb.getInstance();
-        this.serverAccess = new ServerAccess();
         this.notifier = TmcNotificationDisplayer.getDefault();
         this.dialogs = ConvenientDialogDisplayer.getDefault();
         this.beQuiet = beQuiet;
@@ -76,25 +77,30 @@ public void actionPerformed(ActionEvent e) {
         run();
     }
 
-    //"Checking for new exercises" päivitä tämä näkymään progressHandleen myöhemmin
-    /**
-     *
-     */
     public void run() {
         try {
             final Course currentCourseBeforeUpdate = courseDb.getCurrentCourse();
             if (backgroundProcessingOrNoCurrentCourse(currentCourseBeforeUpdate)) {
                 return;
             }
+            ProgressHandle exerciseRefresh = ProgressHandleFactory.createSystemHandle(
+                    "Checking for new exercises");
+            exerciseRefresh.start();
             ListenableFuture<Course> currentCourseFuture = this.tmcCore.getCourse(
-                    NBTmcSettings.getDefault(), currentCourseBeforeUpdate.getDetailsUrl()
+                    NBTmcSettings.getDefault(), detailUrl(currentCourseBeforeUpdate)
             );
-            Futures.addCallback(currentCourseFuture, new UpdateCourseForExerciseUpdate());
+            Futures.addCallback(currentCourseFuture, new UpdateCourseForExerciseUpdate(exerciseRefresh));
         } catch (TmcCoreException ex) {
             Exceptions.printStackTrace(ex);
         }
     }
 
+    private String detailUrl(final Course currentCourseBeforeUpdate) {
+        return ServerAccess.addApiCallQueryParameters(
+                currentCourseBeforeUpdate.getDetailsUrl()
+        );
+    }
+
     /**
      * If there is something at background or no current course is chosen,
      * return true.
@@ -113,25 +119,37 @@ private boolean backgroundProcessingOrNoCurrentCourse(final Course currentCourse
     }
 
     class UpdateCourseForExerciseUpdate implements FutureCallback<Course> {
+        
+        private ProgressHandle lastAction;
 
         /**
          * This should be attached to listenableFuture. When future is ready,
          * receivedCourse will be saved to courseDb and view will be updated.
          */
-        public UpdateCourseForExerciseUpdate() {
+        public UpdateCourseForExerciseUpdate(ProgressHandle lastAction) {
+            this.lastAction = lastAction;
         }
 
         @Override
         public void onSuccess(Course receivedCourse) {
+            lastAction.finish();
             if (receivedCourse != null) {
+                setCourseNameToAllExercises(receivedCourse);
                 courseDb.putDetailedCourse(receivedCourse);
                 final LocalExerciseStatus status = LocalExerciseStatus.get(receivedCourse.getExercises());
                 updateGUI(status);
             }
         }
 
+        private void setCourseNameToAllExercises(Course receivedCourse) {
+            for (Exercise exercise : receivedCourse.getExercises()) {
+                exercise.setCourseName(receivedCourse.getName());
+            }
+        }
+
         private void updateGUI(final LocalExerciseStatus status) {
-            if (status.thereIsSomethingToDownload(false)) {
+            boolean thereIsSomethingToDownload = status.thereIsSomethingToDownload(false);
+            if (thereIsSomethingToDownload) {
                 if (beQuiet) {
                     displayNotification(status, new ActionListener() {
                         @Override
@@ -149,6 +167,7 @@ public void actionPerformed(ActionEvent e) {
 
         @Override
         public void onFailure(Throwable ex) {
+            lastAction.finish();
             if (!beQuiet || ex instanceof ObsoleteClientException) {
                 dialogs.displayError("Failed to check for new exercises.\n" + ServerErrorHelper.getServerExceptionMsg(ex));
             }

tmc-plugin/src/fi/helsinki/cs/tmc/actions/DownloadExercisesAction.java

@@ -3,6 +3,7 @@
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import fi.helsinki.cs.tmc.model.CourseDb;
 import hy.tmc.core.domain.Exercise;
 import fi.helsinki.cs.tmc.model.NBTmcSettings;
 import fi.helsinki.cs.tmc.model.ProjectMediator;
@@ -11,10 +12,15 @@
 import fi.helsinki.cs.tmc.ui.ConvenientDialogDisplayer;
 import hy.tmc.core.TmcCore;
 import hy.tmc.core.exceptions.TmcCoreException;
+import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import javax.swing.SwingUtilities;
+import org.netbeans.api.progress.ProgressHandle;
+import org.netbeans.api.progress.ProgressHandleFactory;
+import org.openide.util.Exceptions;
 
 /**
  * Downloads and opens the given exercises in the background.
@@ -30,6 +36,10 @@ public class DownloadExercisesAction {
     private TmcCore tmcCore;
     private NBTmcSettings settings;
 
+    /**
+     * Downloads all exercises of the list from TmcServer, unzips and opens them and 
+     * saves the checksums of each Exercise to courseDb.
+     */
     public DownloadExercisesAction(List<Exercise> exercisesToOpen) {
         this.projectMediator = ProjectMediator.getInstance();
         this.dialogs = ConvenientDialogDisplayer.getDefault();
@@ -40,18 +50,30 @@ public DownloadExercisesAction(List<Exercise> exercisesToOpen) {
     }
 
     public void run() throws TmcCoreException {
-        // final AggregatingBgTaskListener<TmcProjectInfo> aggregator
-        //         = new AggregatingBgTaskListener<TmcProjectInfo>(exercisesToDownload.size(), whenAllDownloadsFinished);
-
+        ProgressHandle exerciseDownload = ProgressHandleFactory.createSystemHandle(
+                "Downloading " + exercisesToDownload.size() + " exercises.");
+        exerciseDownload.start();
         ListenableFuture<List<Exercise>> dlFuture = tmcCore.downloadExercises(exercisesToDownload, settings);
 
-        Futures.addCallback(dlFuture, new ProjectOpener());
+        Futures.addCallback(dlFuture, new ProjectOpener(exerciseDownload));
     }
 
     private class ProjectOpener implements FutureCallback<List<Exercise>> {
 
+        private ProgressHandle lastAction;
+        
+        /**
+         * Converts Exercise objects to TmcProjectInfo objects.
+         * Saves them to CourseDb and opens them.
+         * @param lastAction 
+         */
+        public ProjectOpener(ProgressHandle lastAction) {
+            this.lastAction = lastAction;
+        }
+
         @Override
         public void onSuccess(List<Exercise> downloadedExercises) {
+            lastAction.finish();
             List<TmcProjectInfo> projects = new ArrayList<TmcProjectInfo>();
             for (Exercise exercise : downloadedExercises) {
                 TmcProjectInfo info = projectMediator.tryGetProjectForExercise(exercise);
@@ -60,14 +82,30 @@ public void onSuccess(List<Exercise> downloadedExercises) {
                 }
                 projects.add(info);
             }
+            saveDownloadedExercisesToCourseDb(downloadedExercises);
             projectMediator.openProjects(projects);
         }
 
+        private void saveDownloadedExercisesToCourseDb(final List<Exercise> downloadedExercises) {
+            try {
+                SwingUtilities.invokeAndWait(new Runnable() {
+                    @Override
+                    public void run() {
+                        CourseDb.getInstance().multipleExerciseDownloaded(downloadedExercises);
+                    }
+                });
+            } catch (InterruptedException ex) {
+                Exceptions.printStackTrace(ex);
+            } catch (InvocationTargetException ex) {
+                Exceptions.printStackTrace(ex);
+            }
+        }
+
         @Override
         public void onFailure(Throwable thrwbl) {
+            lastAction.finish();
             logger.log(Level.INFO, "Failed to download exercise file.", thrwbl);
             dialogs.displayError("Failed to download exercises.\n" + ServerErrorHelper.getServerExceptionMsg(thrwbl));
-
         }
     }
 }

tmc-plugin/src/fi/helsinki/cs/tmc/actions/RefreshCoursesAction.java

@@ -17,6 +17,8 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import org.netbeans.api.progress.ProgressHandle;
+import org.netbeans.api.progress.ProgressHandleFactory;
 import org.openide.util.Exceptions;
 
 /**
@@ -37,14 +39,14 @@ public final class RefreshCoursesAction {
     public RefreshCoursesAction() {
         this(NBTmcSettings.getDefault());
     }
-    
+
     /**
      * Default constructor.
      */
     public RefreshCoursesAction(NBTmcSettings settings) {
         this(settings, TmcCoreSingleton.getInstance());
     }
-    
+
     /**
      * Dependency inject TmcCore for tests.
      */
@@ -69,34 +71,54 @@ public RefreshCoursesAction addListener(FutureCallback<List<Course>> callback) {
     }
 
     /**
-     * Starts downloading course-jsons from TMC-server.
-     * Url of TMC-server is defined in TmcSettings object.
-     * TmcCore includes all logic, callbacks here are run after core-futures are ready.
+     * Starts downloading course-jsons from TMC-server. Url of TMC-server is
+     * defined in TmcSettings object. TmcCore includes all logic, callbacks here
+     * are run after core-futures are ready.
      */
     public void run() {
         try {
+            ProgressHandle courseRefresh = ProgressHandleFactory.createSystemHandle(
+                    "Refreshing course list");
+            courseRefresh.start();
             ListenableFuture<List<Course>> listCourses = this.tmcCore.listCourses(tmcSettings);
-            Futures.addCallback(listCourses, new LoadCourses());
+            Futures.addCallback(listCourses, new LoadCourses(courseRefresh));
         } catch (TmcCoreException ex) {
             Exceptions.printStackTrace(ex);
             callbacks.onFailure(ex);
         }
     }
 
-    /**
-     * This callBack is run when ListenableFuture (to witch this is attached) is done.
-     * On success method takes list of Course-objects, searches the current course and starts uploading
-     * the details of the course.
-     * If no currentCourse found, no need to update details.
-     */
     class LoadCourses implements FutureCallback<List<Course>> {
+
+        private ProgressHandle lastAction;
+
+        /**
+         * This callBack is run when ListenableFuture (to witch this is
+         * attached) is done. On success method takes list of Course-objects,
+         * searches the current course and starts uploading the details of the
+         * course. If no currentCourse found, no need to update details.
+         *
+         * @param ProgressHandle shows to user that action is processing.
+         */
+        public LoadCourses(ProgressHandle lastAction) {
+            this.lastAction = lastAction;
+        }
+
         @Override
         public void onSuccess(final List<Course> courses) {
-            Course currentCourse = CourseListUtils.getCourseByName(courses, courseDb.getCurrentCourseName());
+            lastAction.finish();
+            Course currentCourse = CourseListUtils.getCourseByName(
+                    courses, courseDb.getCurrentCourseName()
+            );
             if (currentCourse != null) {
                 try {
-                    ListenableFuture<Course> courseFuture = tmcCore.getCourse(tmcSettings, currentCourse.getDetailsUrl());
-                    Futures.addCallback(courseFuture, new UpdateCourse(courses));
+                    ProgressHandle loadingCourse = ProgressHandleFactory.
+                            createSystemHandle("Loading course");
+                    loadingCourse.start();
+                    ListenableFuture<Course> courseFuture = tmcCore.getCourse(
+                            tmcSettings, currentCourse.getDetailsUrl()
+                    );
+                    Futures.addCallback(courseFuture, new UpdateCourse(courses, loadingCourse));
                 } catch (TmcCoreException ex) {
                     Exceptions.printStackTrace(ex);
                     callbacks.onFailure(ex);
@@ -108,24 +130,30 @@ public void onSuccess(final List<Course> courses) {
 
         @Override
         public void onFailure(Throwable ex) {
+            lastAction.finish();
             log.log(Level.INFO, "Failed to download current course info.", ex);
             callbacks.onFailure(ex);
         }
     }
 
     /**
-     * When detailed current course is present, courses will be given to FutureCallbackList,
-     * that shares the result to every callback that is attached to that list.
+     * When detailed current course is present, courses will be given to
+     * FutureCallbackList, that shares the result to every callback that is
+     * attached to that list.
      */
     class UpdateCourse implements FutureCallback<Course> {
-        List<Course> courses;
-        
-        public UpdateCourse(List<Course> courses) {
+
+        private List<Course> courses;
+        private ProgressHandle lastAction;
+
+        public UpdateCourse(List<Course> courses, ProgressHandle lastAction) {
             this.courses = courses;
+            this.lastAction = lastAction;
         }
 
         @Override
         public void onSuccess(Course detailedCourse) {
+            lastAction.finish();
             detailedCourse.setExercisesLoaded(true);
             ArrayList<Course> finalCourses = new ArrayList<Course>();
             for (Course course : courses) {
@@ -140,6 +168,7 @@ public void onSuccess(Course detailedCourse) {
 
         @Override
         public void onFailure(Throwable ex) {
+            lastAction.finish();
             log.log(Level.INFO, "Failed to download current course info.", ex);
             callbacks.onFailure(ex);
         }