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