JDK version 7(1.7) is required.

 or

 or using web browser (for windows)

 ### Unzip

 ### Change directory to unzipped directory

 ### Download Yobi

 **Caution! in case2, You might come across troubles when you try to upgrade Yobi.**

 ### Change directory to cloned Yobi directory (or cd to your unzipped file directory)

     cd yobi

 or (for windows)

 Required files will be download automatically. In the first time, it may take about 10 min or more.

 Also, you can configure start options.

 If your system's memory is over than 4G, we recommend to use follow options.

 ### Connect with browser

 If you want to change port, check your permission to use 80 port

 ### Upgrade Yobi

 JDK 7(1.7)이어야 합니다.

 혹은

 웹 브라우저에서 (이를테면, MS윈도우즈 사용자일 경우)

 ### 압축풀기

 ### 압축을 푼 다음 하위 디렉터리로 이동

 ### Yobi 소스 내려 받기

 주의! case2의 경우, 업그레이드를 할 때 문제가 생길 수 있습니다.

 ### clone 받은 Yobi 디렉터리로 이동 

 (혹은 압축을 해제한 디렉터리로 이동)

     cd yobi

 혹은 (윈도우 사용자일 경우)

 실행하면 필요한 파일들을 web에서 내려받습니다. 첫 실행시 네트워크 상황에 따라 10여분 가까이 소요될 수 있습니다.

 시작 옵션은 조정가능합니다. 만약 시스템 메모리가 4기가 이상이라면

 아래 옵션으로 실행하는걸 권장합니다.

 ### 브라우저로 접속

     http://127.0.0.1:9000

 80 포트 등으로 포트를 변경하고 싶을 경우에는 해당 포트가 사용가능한지 확인 한 다음 80 포트를 사용할 수 있는 계정으로 실행합니다.

 ### 업그레이드 하기

 import play.data.Form;

 import play.mvc.*;

 import play.mvc.Http.RequestHeader;

 import utils.AccessControl;

 import utils.AccessLogger;

 import views.html.welcome.restart;

 import static play.data.Form.form;

 import static play.mvc.Results.badRequest;

 public class Global extends GlobalSettings {

     private static final String[] INITIAL_ENTITY_NAME = {"users", "roles", "siteAdmins"};

     private Action<Void> getDefaultAction(final Http.Request request) {

         final long start = System.currentTimeMillis();

         return new Action.Simple() {

                 UserApp.initTokenUser();

                 UserApp.updatePreferredLanguage();

                 ctx.response().setHeader("Date", DateUtils.formatDate(new Date()));

                 ctx.response().setHeader("Cache-Control", "no-cache");

             }

         };

     }

     private Action<Void> getRestartAction() {

         return new Action.Simple() {

             @Override

             }

         };

     }

     private Action<Void> getConfigSecretAction() {

         return new Action.Simple() {

             @Override

                 if( ctx.request().method().toLowerCase().equals("post") ) {

                     Form<User> newSiteAdminUserForm = form(User.class).bindFromRequest();

                     if (hasError(newSiteAdminUserForm)) {

                     }

                     User siteAdmin = SiteAdmin.updateDefaultSiteAdmin(newSiteAdminUserForm.get());

                     replaceSiteSecretKey(createSeed(siteAdmin.password));

                     isRestartRequired = true;

                 } else {

                 }

             }

     }

     @Override

         AccessLogger.log(request, null, Http.Status.NOT_FOUND);

     }

     @Override

         AccessLogger.log(request, null, Http.Status.INTERNAL_SERVER_ERROR);

         if (Play.isProd()) {

         } else {

             return super.onError(request, t);

         }

     }

     @Override

         AccessLogger.log(request, null, Http.Status.BAD_REQUEST);

     }

 }

 import play.mvc.Action;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import utils.AccessControl;

 import utils.AccessLogger;

 import utils.ErrorViews;

  */

 public abstract class AbstractProjectCheckAction<T> extends Action<T> {

     @Override

         PathParser parser = new PathParser(context);

         String ownerLoginId = parser.getOwnerLoginId();

         String projectName = parser.getProjectName();

         Project project = Project.findByOwnerAndProjectName(ownerLoginId, projectName);

         if (project == null) {

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

                 flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

             }

         }

         if (!AccessControl.isAllowed(UserApp.currentUser(), project.asResource(), Operation.READ)) {

             flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

         }

         return call(project, context, parser);

     }

             throws Throwable;

 }

 import play.mvc.Action;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import utils.AccessControl;

 import utils.AccessLogger;

 import utils.Constants;

 public class AnonymousCheckAction extends Action<AnonymousCheck> {

     @Override

         if ((AccessControl.isAnonymousNotAllowed() || configuration.requiresLogin()) &&

                 UserApp.currentUser().isAnonymous()) {

             if (configuration.displaysFlashMessage()) {

             }

             String loginFormUrl = routes.UserApp.loginForm().url();

             loginFormUrl += "?redirectUrl=" + context.request().path();

         }

         return delegate.call(context);

     }

 import models.Project;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 /**

  * Default implementation of {@link AbstractProjectCheckAction}.

  */

 public class DefaultProjectCheckAction extends AbstractProjectCheckAction<Void> {

     @Override

         return this.delegate.call(context);

     }

 }

 import models.resource.ResourceConvertible;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import utils.AccessControl;

 import utils.AccessLogger;

 import utils.ErrorViews;

  */

 public class IsAllowedAction extends AbstractProjectCheckAction<IsAllowed> {

     @Override

         ResourceType resourceType = this.configuration.resourceType();

         ResourceConvertible resourceObject = Resource.getResourceObject(parser, project, resourceType);

         Operation operation = this.configuration.value();

         if(resourceObject == null) {

         }

         if(!AccessControl.isAllowed(UserApp.currentUser(), resourceObject.asResource(), operation)) {

         }

         return this.delegate.call(context);

 import models.User;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import utils.AccessControl;

 import utils.AccessLogger;

 import utils.ErrorViews;

  */

 public class IsCreatableAction extends AbstractProjectCheckAction<IsCreatable> {

     @Override

         User currentUser = UserApp.currentUser();

         if (!AccessControl.isProjectResourceCreatable(currentUser, project, this.configuration.value())) {

         }

         return this.delegate.call(context);

 import models.Project;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import utils.AccessLogger;

 import utils.ErrorViews;

  */

 public class IsOnlyGitAvailableAction extends AbstractProjectCheckAction<IsOnlyGitAvailable> {

     @Override

         if(!project.isGit()) {

         }

         return this.delegate.call(context);

 import play.mvc.Action;

 import play.mvc.Http;

 import play.mvc.Result;

 import utils.AccessLogger;

 import utils.ErrorViews;

 public class NullProjectCheckAction extends Action<Void> {

     @Override

         PathParser parser = new PathParser(context);

         String ownerLoginId = parser.getOwnerLoginId();

         String projectName = parser.getProjectName();

         Project project = Project.findByOwnerAndProjectName(ownerLoginId, projectName);

         if (project == null) {

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

                 flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

             }

         }

         return this.delegate.call(context);

 import playRepository.RepositoryService;

 import views.html.error.notfound_default;

 import views.html.index.index;

 import java.io.File;

         return redirect(routes.Application.index());

     }

     public static Result jsMessages() {

     }

     private static void makeUploadFolder() {

 import models.enumeration.Operation;

 import models.enumeration.ResourceType;

 import org.apache.commons.lang3.StringUtils;

 import play.Configuration;

 import play.Logger;

 import play.mvc.Controller;

 import models.enumeration.ResourceType;

 import org.apache.commons.lang3.StringUtils;

 import play.data.Form;

 import play.db.ebean.Transactional;

 import org.apache.commons.io.FilenameUtils;

 import org.apache.tika.Tika;

 import org.apache.tika.mime.MediaType;

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

 import org.tmatesoft.svn.core.SVNException;

 import play.mvc.*;

         List<ObjectNode> recursiveData = new ArrayList<>();

         List<String> branches = repository.getBranchNames();

             recursiveData.addAll(RepositoryService.getMetaDataFromAncestorDirectories(repository, branch, path));

         }

         recursiveData.add(fileInfo);

 import models.enumeration.State;

 import org.apache.commons.lang3.StringUtils;

 import org.apache.tika.Tika;

 import play.data.Form;

 import play.data.validation.ValidationError;

 import play.db.ebean.Transactional;

 import models.enumeration.Operation;

 import models.enumeration.RequestState;

 import models.enumeration.RoleType;

 import play.data.Form;

 import play.data.validation.Validation;

 import play.db.ebean.Transactional;

 import org.apache.commons.lang.exception.ExceptionUtils;

 import org.apache.commons.lang3.StringUtils;

 import org.apache.commons.mail.HtmlEmail;

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

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

 import org.tmatesoft.svn.core.SVNException;

             return notFound(ErrorViews.NotFound.render("error.notfound"));

         }

         targetProject.save();

         ObjectNode result = Json.newObject();

         if (label == null) {

             // Create new label if there is no label which has the given name.

             label = new Label(category, name);

             label.save();

             isCreated = true;

         }

         Boolean isAttached = project.attachLabel(label);

             // Something is wrong. This case is not possible.

             play.Logger.warn(

                     "A label '" + label + "' is created but failed to attach to project '" + project + "'.");

 import actors.PullRequestMergingActor;

 import akka.actor.Props;

 import com.avaje.ebean.Page;

 import controllers.annotation.AnonymousCheck;

 import controllers.annotation.IsAllowed;

 import controllers.annotation.IsCreatable;

 import controllers.annotation.IsOnlyGitAvailable;

 import models.*;

 import models.enumeration.Operation;

 import models.enumeration.ResourceType;

 import models.enumeration.RoleType;

 import models.enumeration.State;

 import org.apache.commons.lang3.StringUtils;

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

 import org.tmatesoft.svn.core.SVNException;

 import play.api.mvc.Call;

 import play.data.Form;

 import play.db.ebean.Transactional;

 import play.libs.Akka;

 import play.libs.F.Function;

 import play.libs.F.Promise;

 import play.libs.Json;

 import play.mvc.Controller;

 import play.mvc.Result;

 import playRepository.GitBranch;

 import playRepository.GitRepository;

 import playRepository.RepositoryService;

 import utils.*;

 import views.html.error.notfound;

 import javax.servlet.ServletException;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Map;

 @IsOnlyGitAvailable

 @AnonymousCheck

         PullRequestEventMessage message = new PullRequestEventMessage(

                 UserApp.currentUser(), request(), pullRequest);

         return redirect(pullRequestCall);

     }

                                             long pullRequestNumber, String commitId) {

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

         PullRequest pullRequest = PullRequest.findOne(project, pullRequestNumber);

     }

     @Transactional

     @AnonymousCheck(requiresLogin = true, displaysFlashMessage = true)

     @IsAllowed(value = Operation.ACCEPT, resourceType = ResourceType.PULL_REQUEST)

                                 final long pullRequestNumber) {

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

         final PullRequest pullRequest = PullRequest.findOne(project, pullRequestNumber);

                 UserApp.currentUser(), request(), project, pullRequest.toBranch);

         if(project.isUsingReviewerCount && !pullRequest.isReviewed()) {

         }

             @Override

             public Result apply(Void v) throws Throwable {

                 return redirect(routes.PullRequestApp.pullRequest(userName, projectName,

                         pullRequestNumber));

             }

     }

     private static void addNotification(PullRequest pullRequest, State from, State to) {

         PullRequestEventMessage message = new PullRequestEventMessage(

                 UserApp.currentUser(), request(), pullRequest);

         return redirect(call);

     }

 import org.apache.shiro.crypto.SecureRandomNumberGenerator;

 import org.apache.shiro.crypto.hash.Sha256Hash;

 import org.apache.shiro.util.ByteSource;

 import play.Configuration;

 import play.Logger;

 import play.Play;

 import play.db.ebean.Model;

 import play.libs.Akka;

 import scala.concurrent.duration.Duration;

 import utils.FileUtil;

 import utils.JodaDateUtil;

         this.token = RandomStringUtils.randomNumeric(50);

         this.confirmUrl = Url.create(routes.UserApp.confirmEmail(this.id, this.token).url());

         update();

     }

     public static Email findByEmail(String email, boolean isValid) {

     }

     public Boolean attachLabel(Label label) {

             // Return false if the label has been already attached.

             return false;

         }