python/educational-core/course-creator/src/com/jetbrains/edu/coursecreator/actions/CCCreateCourseArchive.java

   1 package com.jetbrains.edu.coursecreator.actions;
   2
   3 import com.google.gson.Gson;
   4 import com.google.gson.GsonBuilder;
   5 import com.intellij.ide.projectView.ProjectView;
   6 import com.intellij.openapi.actionSystem.AnActionEvent;
   7 import com.intellij.openapi.actionSystem.CommonDataKeys;
   8 import com.intellij.openapi.actionSystem.LangDataKeys;
   9 import com.intellij.openapi.actionSystem.Presentation;
  10 import com.intellij.openapi.application.ApplicationManager;
  11 import com.intellij.openapi.diagnostic.Logger;
  12 import com.intellij.openapi.module.Module;
  13 import com.intellij.openapi.project.DumbAwareAction;
  14 import com.intellij.openapi.project.Project;
  15 import com.intellij.openapi.ui.DialogWrapper;
  16 import com.intellij.openapi.ui.Messages;
  17 import com.intellij.openapi.util.Condition;
  18 import com.intellij.openapi.util.io.FileUtil;
  19 import com.intellij.openapi.vfs.VfsUtil;
  20 import com.intellij.openapi.vfs.VirtualFile;
  21 import com.intellij.openapi.vfs.VirtualFileManager;
  22 import com.intellij.util.containers.ContainerUtil;
  23 import com.intellij.util.io.ZipUtil;
  24 import com.jetbrains.edu.coursecreator.CCLanguageManager;
  25 import com.jetbrains.edu.coursecreator.CCUtils;
  26 import com.jetbrains.edu.coursecreator.ui.CreateCourseArchiveDialog;
  27 import com.jetbrains.edu.learning.StudyTaskManager;
  28 import com.jetbrains.edu.learning.core.EduNames;
  29 import com.jetbrains.edu.learning.core.EduUtils;
  30 import com.jetbrains.edu.learning.courseFormat.Course;
  31 import com.jetbrains.edu.learning.courseFormat.Lesson;
  32 import com.jetbrains.edu.learning.courseFormat.Task;
  33 import com.jetbrains.edu.learning.statistics.EduUsagesCollector;
  34 import org.jetbrains.annotations.NotNull;
  35
  36 import java.io.*;
  37 import java.util.Arrays;
  38 import java.util.List;
  39 import java.util.zip.ZipOutputStream;
  40
  41 public class CCCreateCourseArchive extends DumbAwareAction {
  42   private static final Logger LOG = Logger.getInstance(CCCreateCourseArchive.class.getName());
  43   public static final String GENERATE_COURSE_ARCHIVE = "Generate Course Archive";
  44   private String myZipName;
  45   private String myLocationDir;
  46
  47   public void setZipName(String zipName) {
  48     myZipName = zipName;
  49   }
  50
  51   public void setLocationDir(String locationDir) {
  52     myLocationDir = locationDir;
  53   }
  54
  55   public CCCreateCourseArchive() {
  56     super(GENERATE_COURSE_ARCHIVE, GENERATE_COURSE_ARCHIVE, null);
  57   }
  58
  59   @Override
  60   public void update(@NotNull AnActionEvent e) {
  61     Presentation presentation = e.getPresentation();
  62     Project project = e.getProject();
  63     presentation.setEnabledAndVisible(project != null && CCUtils.isCourseCreator(project));
  64   }
  65
  66   @Override
  67   public void actionPerformed(@NotNull AnActionEvent e) {
  68     final Project project = e.getData(CommonDataKeys.PROJECT);
  69     final Module module = e.getData(LangDataKeys.MODULE);
  70     if (project == null || module == null) {
  71       return;
  72     }
  73     CreateCourseArchiveDialog dlg = new CreateCourseArchiveDialog(project, this);
  74     dlg.show();
  75     if (dlg.getExitCode() != DialogWrapper.OK_EXIT_CODE) {
  76       return;
  77     }
  78     createCourseArchive(project, module, myZipName, myLocationDir, true);
  79     EduUsagesCollector.createdCourseArchive();
  80   }
  81
  82   public static void createCourseArchive(final Project project, Module module, String zipName, String locationDir, boolean showMessage) {
  83     final Course course = StudyTaskManager.getInstance(project).getCourse();
  84     if (course == null) return;
  85     final VirtualFile baseDir = project.getBaseDir();
  86     VirtualFile archiveFolder = CCUtils.generateFolder(project, module, zipName);
  87     if (archiveFolder == null) {
  88       return;
  89     }
  90
  91     CCLanguageManager manager = CCUtils.getStudyLanguageManager(course);
  92     if (manager == null) {
  93       return;
  94     }
  95     FileFilter filter = pathname -> !manager.doNotPackFile(pathname);
  96
  97     for (VirtualFile child : baseDir.getChildren()) {
  98       String name = child.getName();
  99       File fromFile = new File(child.getPath());
 100       if (CCUtils.GENERATED_FILES_FOLDER.equals(name) || ".idea".equals(name)
 101           || name.contains("iml") || manager.doNotPackFile(fromFile)) {
 102         continue;
 103       }
 104       copyChild(archiveFolder, filter, child, fromFile);
 105     }
 106
 107     ApplicationManager.getApplication().runWriteAction(new Runnable() {
 108       @Override
 109       public void run() {
 110         Course courseCopy = course.copy();
 111         replaceAnswerFilesWithTaskFiles(courseCopy);
 112         generateJson(archiveFolder, courseCopy);
 113         VirtualFileManager.getInstance().refreshWithoutFileWatcher(false);
 114         packCourse(archiveFolder, locationDir, zipName, showMessage);
 115         synchronize(project);
 116       }
 117
 118       private void replaceAnswerFilesWithTaskFiles(Course courseCopy) {
 119         for (Lesson lesson : courseCopy.getLessons()) {
 120           String lessonDirName = EduNames.LESSON + String.valueOf(lesson.getIndex());
 121           final VirtualFile lessonDir = baseDir.findChild(lessonDirName);
 122           if (lessonDir == null) continue;
 123           for (Task task : lesson.getTaskList()) {
 124             final VirtualFile taskDir = task.getTaskDir(project);
 125             if (taskDir == null) continue;
 126             String taskDirName = EduNames.TASK + String.valueOf(task.getIndex());
 127             VirtualFile studentFileDir = VfsUtil.findRelativeFile(archiveFolder, lessonDirName, taskDirName);
 128             if (studentFileDir == null) {
 129               continue;
 130             }
 131             VirtualFile srcDir = studentFileDir.findChild(EduNames.SRC);
 132             if (srcDir != null) {
 133               studentFileDir = srcDir;
 134             }
 135             if (task.hasSubtasks()) {
 136               transformSubtaskTestsToTextFiles(studentFileDir);
 137             }
 138             for (String taskFile : task.getTaskFiles().keySet()) {
 139               VirtualFile answerFile = taskDir.findChild(taskFile);
 140               if (answerFile == null) {
 141                 continue;
 142               }
 143               EduUtils.createStudentFile(this, project, answerFile, studentFileDir, task, 0);
 144             }
 145           }
 146         }
 147       }
 148
 149       private void transformSubtaskTestsToTextFiles(VirtualFile studentFileDir) {
 150         Condition<VirtualFile> isSubtaskTestFile =
 151           file -> CCUtils.isTestsFile(project, file) && file.getName().contains(EduNames.SUBTASK_MARKER);
 152         List<VirtualFile> subtaskTests = ContainerUtil.filter(Arrays.asList(studentFileDir.getChildren()), isSubtaskTestFile);
 153         for (VirtualFile subtaskTest : subtaskTests) {
 154           try {
 155             subtaskTest.rename(this, subtaskTest.getNameWithoutExtension() + ".txt");
 156           }
 157           catch (IOException e) {
 158             LOG.error(e);
 159           }
 160         }
 161       }
 162     });
 163   }
 164
 165   private static void copyChild(VirtualFile archiveFolder, FileFilter filter, VirtualFile child, File fromFile) {
 166     File toFile = new File(archiveFolder.getPath(), child.getName());
 167
 168     try {
 169       if (child.isDirectory()) {
 170         FileUtil.copyDir(fromFile, toFile, filter);
 171       }
 172       else {
 173         if (filter.accept(fromFile)) {
 174           FileUtil.copy(fromFile, toFile);
 175         }
 176       }
 177     }
 178     catch (IOException e) {
 179       LOG.info("Failed to copy" + fromFile.getPath(), e);
 180     }
 181   }
 182
 183   private static void synchronize(@NotNull final Project project) {
 184     VirtualFileManager.getInstance().refreshWithoutFileWatcher(true);
 185     ProjectView.getInstance(project).refresh();
 186   }
 187
 188   private static void packCourse(@NotNull final VirtualFile baseDir, String locationDir, String zipName, boolean showMessage) {
 189     try {
 190       final File zipFile = new File(locationDir, zipName + ".zip");
 191       ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zipFile)));
 192       VirtualFile[] courseFiles = baseDir.getChildren();
 193       for (VirtualFile file : courseFiles) {
 194         ZipUtil.addFileOrDirRecursively(zos, null, new File(file.getPath()), file.getName(), null, null);
 195       }
 196       zos.close();
 197       if (showMessage) {
 198         Messages.showInfoMessage("Course archive was saved to " + zipFile.getPath(), "Course Archive Was Created Successfully");
 199       }
 200     }
 201     catch (IOException e1) {
 202       LOG.error(e1);
 203     }
 204   }
 205
 206   @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
 207   private static void generateJson(VirtualFile parentDir, Course course) {
 208     final Gson gson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create();
 209     final String json = gson.toJson(course);
 210     final File courseJson = new File(parentDir.getPath(), EduNames.COURSE_META_FILE);
 211     OutputStreamWriter outputStreamWriter = null;
 212     try {
 213       outputStreamWriter = new OutputStreamWriter(new FileOutputStream(courseJson), "UTF-8");
 214       outputStreamWriter.write(json);
 215     }
 216     catch (Exception e) {
 217       Messages.showErrorDialog(e.getMessage(), "Failed to Generate Json");
 218       LOG.info(e);
 219     }
 220     finally {
 221       try {
 222         if (outputStreamWriter != null) {
 223           outputStreamWriter.close();
 224         }
 225       }
 226       catch (IOException e1) {
 227         //close silently
 228       }
 229     }
 230   }
 231 }