Ebean.save(all.get("issueComments"));

             Ebean.save(all.get("posts"));

             Ebean.save(all.get("comments"));

             Ebean.save(all.get("roles"));

             Ebean.save(all.get("projectUsers"));

             Ebean.save(all.get("taskBoards"));

             Ebean.save(all.get("cards"));

             Ebean.save(all.get("labels"));

             Ebean.save(all.get("checkLists"));

         }

     }

 import java.util.Map;

 import models.Attachment;

 import models.enumeration.Operation;

 import models.enumeration.Resource;

             return notFound();

         }

             return forbidden();

         }

             return notFound();

         }

             return forbidden();

         }

             List<Map<String, String>> attachments = new ArrayList<Map<String, String>>();

             for (Attachment attach : Attachment.findByContainer(Resource.valueOf(containerType),

                     Long.parseLong(containerId))) {

                     return forbidden();

                 }

                 attachments.add(fileAsMap(attach));

 import models.Comment;

 import models.Post;

 import models.Project;

 import models.enumeration.Direction;

 import models.enumeration.Operation;

 import models.enumeration.Resource;

 import views.html.board.postList;

 public class BoardApp extends Controller {

     //TODO 이 클래스는 원래 따로 존재해야 함.

     public static class SearchCondition{

         public final static String ORDERING_KEY_ID = "id";

         public final static String ORDERING_KEY_TITLE = "title";

         public final static String ORDERING_KEY_AGE = "date";

         public final static String ORDERING_KEY_AUTHOR = "authorName";

         public SearchCondition() {

             this.order = Direction.DESC.direction();

             this.key = ORDERING_KEY_ID;

         public String filter;

         public int pageNum;

     }

     public static Result posts(String userName, String projectName) {

         Form<SearchCondition> postParamForm = new Form<SearchCondition>(SearchCondition.class);

         SearchCondition postSearchCondition = postParamForm.bindFromRequest().get();

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

     public static Result newPostForm(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

     public static Result post(String userName, String projectName, Long postId) {

         Post post = Post.findById(postId);

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         Form<Post> editForm = new Form<Post>(Post.class).fill(existPost);

         Project project = ProjectApp.getProject(userName, projectName);

             return ok(editPost.render("board.post.modify", editForm, postId, project));

         } else {

             flash(Constants.WARNING, "board.notAuthor");

 import javax.servlet.ServletException;

 import models.Project;

 import org.eclipse.jgit.api.errors.GitAPIException;

 import org.eclipse.jgit.api.errors.NoHeadException;

 import play.mvc.Controller;

 import play.mvc.Result;

 import playRepository.Commit;

 import playRepository.RepositoryService;

 import utils.AccessControl;

 import utils.HttpUtil;

             UnsupportedOperationException, ServletException, GitAPIException,

             SVNException {

         Project project = Project.findByNameAndOwner(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         }

         try {

             return ok(history.render(project, commits, page, branch));

         } catch (NoHeadException e) {

             return ok(nohead.render(project));

             throws IOException, UnsupportedOperationException, ServletException, GitAPIException,

             SVNException {

         Project project = Project.findByNameAndOwner(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         String patch = RepositoryService.getRepository(project).getPatch(commitId);

 import play.mvc.Controller;

 import play.mvc.Result;

 import play.mvc.With;

 import playRepository.RepositoryService;

 import utils.AccessControl;

 import utils.BasicAuthAction;

                 && (service.equals("git-upload-pack") || service.equals("git-receive-pack"));

     }

         Project project = ProjectApp.getProject(userName, projectName);

         if (service.equals("git-upload-pack")) {

             operation = Operation.READ;

         }

             return true;

         }

 import java.io.IOException;

 import java.io.UnsupportedEncodingException;

 import java.util.List;

 import jxl.write.WriteException;

 import models.IssueLabel;

 import models.Project;

 import models.enumeration.Direction;

 import models.enumeration.Resource;

 import models.enumeration.State;

 import models.support.FinderTemplate;

 	@Cached(key = "issues")

     public static Result issues(String userName, String projectName, String state, String format) throws WriteException, IOException {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

     public static Result newIssueForm(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         Issue targetIssue = Issue.findById(id);

         Form<Issue> editForm = new Form<Issue>(Issue.class).fill(targetIssue);

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         return redirect(routes.IssueApp.issue(project.owner, project.name, issueId));

     }

             return notFound();

         }

             return forbidden();

         }

 import models.ProjectUser;

 import models.Role;

 import models.User;

 import models.enumeration.RoleType;

 import models.task.CardAssignee;

 import play.cache.Cached;

 //    @Cached(key = "project")

     public static Result project(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

     public static Result settingForm(String userName, String projectName) {

         Project project = getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         Form<Project> filledUpdatedProjectForm = form(Project.class)

                 .bindFromRequest();

         Project project = filledUpdatedProjectForm.get();

         if(!ProjectUser.isManager(UserApp.currentUser().id, project.id)){

             flash(Constants.WARNING, "project.member.isManager");

             return redirect(routes.ProjectApp.settingForm(userName, project.name));

         MultipartFormData body = request().body().asMultipartFormData();

         FilePart filePart = body.getFile("logoPath");

         if (filePart != null) {

         	if(!isImageFile(filePart.getFilename())) {

         		flash(Constants.WARNING, "project.logo.alert");

     }

     public static boolean isImageFile(String filename) {

     }

     public static Result deleteProject(String userName, String projectName) throws Exception {

         Project project = getProject(userName, projectName);

         if (ProjectUser.isManager(UserApp.currentUser().id, project.id)) {

 import play.mvc.Controller;

 import play.mvc.Result;

 import play.mvc.With;

 import playRepository.RepositoryService;

 import utils.AccessControl;

 import utils.BasicAuthAction;

 public class SvnApp extends Controller {

     static DAVServlet davServlet;

     @With(BasicAuthAction.class)

     @BodyParser.Of(BodyParser.Raw.class)

     public static Result serviceWithPath(String path) throws ServletException, IOException {

         User currentUser = UserApp.currentUser();

         // Check the user has a permission to access this repository.

         Project project = Project.findByNameAndOwner(userName, projectName);

             if (currentUser.id == UserApp.anonymous.id) {

                 return BasicAuthAction.unauthorized(response());

             } else {

                 || DAVHandlerFactory.METHOD_REPORT.equals(method)) {

             return Operation.READ;

         } else {

         }

     }

 import java.util.Map;

 import models.Project;

 import models.task.Card;

 import models.task.Line;

 import models.task.TaskBoard;

 public class TaskApp extends Controller {

     public static Result index(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         return ok(taskView.render(project));

     public static Result card(String userName, String projectName, Long cardId) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

     public static Result getLabels(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         TaskBoard taskBoard = TaskBoard.findByProject(project);

     public static Result getMember(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         TaskBoard taskBoard = TaskBoard.findByProject(project);

     // TestCode 나중에 전부 웹소켓으로 바꾼다. 당연히 그걸 고려해서 짜야한다.

     public static Result cardView(String userName, String projectName) {

         Project project = ProjectApp.getProject(userName, projectName);

             return unauthorized(views.html.project.unauthorized.render(project));

         }

         return ok(cardView.render(project));

     }

     // TestCode End

     public static WebSocket<String> connect(String userName, String projectName) {

         return WebSocketServer.handelWebSocket(userName, projectName);

     }

 import javax.persistence.ManyToOne;

 import javax.persistence.OneToMany;

 import play.data.validation.Constraints.Required;

 import play.db.ebean.Model;

 @Entity

 public class Assignee extends Model {

     @OneToMany(mappedBy = "assignee", cascade = CascadeType.ALL)

     public Set<Issue> issues;

             Assignee.class);

     public Assignee(Long userId, Long projectId) {

 import org.apache.commons.io.FileUtils;

 import org.apache.tika.Tika;

 import models.enumeration.Resource;

 import play.data.validation.*;

     public Long containerId;

     /**

      * @param userId

      * @return

      */

             attachment.delete();

         }

     }

 }

 package models;

 import org.joda.time.*;

 import play.data.validation.*;

 import play.db.ebean.*;

     public static void delete(Long commentId) {

         find.byId(commentId).delete();

     }

 }

 import jxl.format.Alignment;

 import jxl.write.*;

 import models.enumeration.*;

 import models.support.*;

 import org.joda.time.*;

 import play.data.format.*;

 	public boolean isClosed() {

 	    return this.state == State.CLOSED;

 	}

 package models;

 import org.joda.time.*;

 import play.data.validation.*;

 import play.db.ebean.*;

     public Duration ago() {

         return JodaDateUtil.ago(this.date);

     }

 }

 import play.db.ebean.*;

 import javax.persistence.*;

 import java.util.*;

 @Entity

         }

         super.delete();

     }

 }

 import com.avaje.ebean.*;

 import controllers.*;

 import models.enumeration.*;

 import models.support.*;

 import org.joda.time.*;

 import play.data.format.*;

     @Constraints.Required

     public String contents;

     @Constraints.Required

     @Formats.DateTime(pattern = "YYYY/MM/DD/hh/mm/ss")

     public Date date;

         }

         post.update();

     }

     public static boolean isAuthor(Long currentUserId, Long id) {

         int findRowCount = finder.where().eq("authorId", currentUserId).eq("id", id).findRowCount();

         return (findRowCount != 0) ? true : false;

         post.commentCount--;

         post.update();