Merge pull request #1073 from gitblit/1062-DocEditorUpdates

Paul Martin

2016-04-30 a502d96a860456ec5e8c96761db70f7cabb74751

 src/main/java/com/gitblit/wicket/panels/RepositoryUrlPanel.java

@@ -15,229 +15,469 @@
 */

package com.gitblit.wicket.panels;



import java.io.Serializable;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



import javax.servlet.http.HttpServletRequest;



import org.apache.wicket.Component;

import org.apache.wicket.Localizer;

import org.apache.wicket.RequestCycle;

import org.apache.wicket.markup.html.basic.Label;

import org.apache.wicket.markup.html.image.ContextImage;

import org.apache.wicket.markup.html.panel.Fragment;

import org.apache.wicket.markup.repeater.Item;

import org.apache.wicket.markup.repeater.data.DataView;

import org.apache.wicket.markup.repeater.data.ListDataProvider;

import org.apache.wicket.protocol.http.WebRequest;

import org.apache.wicket.protocol.http.request.WebClientInfo;



import com.gitblit.Constants;

import com.gitblit.Constants.AccessPermission;

import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.GitBlit;

import com.gitblit.Keys;

import com.gitblit.SparkleShareInviteServlet;

import com.gitblit.models.GitClientApplication;

import com.gitblit.models.RepositoryModel;

import com.gitblit.models.RepositoryUrl;

import com.gitblit.models.UserModel;

import com.gitblit.utils.StringUtils;

import com.gitblit.wicket.ExternalImage;

import com.gitblit.wicket.GitBlitWebSession;

import com.gitblit.wicket.WicketUtils;



/**

 * Smart repository url panel which can display multiple Gitblit repository urls

 * and also supports 3rd party app clone links.

 * 
 *

 * @author James Moger

 *

 */

public class RepositoryUrlPanel extends BasePanel {



   private static final long serialVersionUID = 1L;

	
   private final String primaryUrl;



   public RepositoryUrlPanel(String wicketId, boolean onlyPrimary, UserModel user, 
         RepositoryModel repository, Localizer localizer, Component owner) {

   private final String externalPermission = "?";



   private boolean onlyUrls;

   private UserModel user;

   private RepositoryModel repository;

   private RepositoryUrl primaryUrl;

   private Map<String, String> urlPermissionsMap;

   private Map<AccessRestrictionType, String> accessRestrictionsMap;



   public RepositoryUrlPanel(String wicketId, boolean onlyUrls, UserModel user, RepositoryModel repository) {

      super(wicketId);

      if (user == null) {

         user = UserModel.ANONYMOUS;

      }

      List<String> repositoryUrls = new ArrayList<String>();

      this.onlyUrls = onlyUrls;

      this.user = user == null ? UserModel.ANONYMOUS : user;

      this.repository = repository;

      this.urlPermissionsMap = new HashMap<String, String>();

   }



      AccessPermission accessPermission = null;

      if (GitBlit.getBoolean(Keys.git.enableGitServlet, true)) {

         accessPermission = user.getRepositoryPermission(repository).permission;

         repositoryUrls.add(getRepositoryUrl(repository));

      }

      repositoryUrls.addAll(GitBlit.self().getOtherCloneUrls(repository.name, UserModel.ANONYMOUS.equals(user) ? "" : user.username));

		
      primaryUrl = repositoryUrls.size() == 0 ? "" : repositoryUrls.remove(0);

   @Override

   protected void onInitialize() {

      super.onInitialize();



      add(new DetailedRepositoryUrlPanel("repositoryPrimaryUrl", localizer, owner, repository.name, primaryUrl, accessPermission));

		
      if (!onlyPrimary) {

         Component gitDaemonUrlPanel = createGitDaemonUrlPanel("repositoryGitDaemonUrl", user, repository);

         if (!StringUtils.isEmpty(primaryUrl) && gitDaemonUrlPanel instanceof DetailedRepositoryUrlPanel) {

            WicketUtils.setCssStyle(gitDaemonUrlPanel, "padding-top: 10px");

         }

         add(gitDaemonUrlPanel);

      HttpServletRequest req = ((WebRequest) getRequest()).getHttpServletRequest();



      List<RepositoryUrl> repositoryUrls = app().services().getRepositoryUrls(req, user, repository);

      // grab primary url from the top of the list

      primaryUrl = repositoryUrls.size() == 0 ? null : repositoryUrls.get(0);



      boolean canClone = primaryUrl != null && (!primaryUrl.hasPermission() || primaryUrl.permission.atLeast(AccessPermission.CLONE));



      if (repositoryUrls.size() == 0 || !canClone) {

         // no urls, nothing to show.

         add(new Label("repositoryUrlPanel").setVisible(false));

         add(new Label("applicationMenusPanel").setVisible(false));

         add(new Label("repositoryIndicators").setVisible(false));

         return;

      }



      // display primary url

      add(createPrimaryUrlPanel("repositoryUrlPanel", repository, repositoryUrls));



      if (onlyUrls) {

         add(new Label("repositoryIndicators").setVisible(false));

      } else {

         add(new Label("repositoryGitDaemonUrl").setVisible(false));

      }

		
      String cloneWith = localizer.getString("gb.cloneWithApp", owner);

      final List<AppCloneLink> cloneLinks = new ArrayList<AppCloneLink>();

      if (user.canClone(repository) && GitBlit.getBoolean(Keys.web.allowAppCloneLinks, true)) {

         // universal app clone urls

//         cloneLinks.add(new AppCloneLink(MessageFormat.format(cloneWith, "SmartGit\u2122"),

//               MessageFormat.format("smartgit://cloneRepo/{0}", primaryUrl),

//               "Syntevo SmartGit\u2122"));



         if (isWindows()) {

            // Windows client app clone urls

            cloneLinks.add(new AppCloneLink(MessageFormat.format(cloneWith, "SourceTree\u2122"),

                  MessageFormat.format("sourcetree://cloneRepo/{0}", primaryUrl),

                  "Atlassian SourceTree\u2122"));

//            cloneLinks.add(new AppCloneLink(

//                  MessageFormat.format(cloneWith, "GitHub\u2122 for Windows"),

//                  MessageFormat.format("github-windows://openRepo/{0}", primaryUrl),

//                  "GitHub\u2122 for Windows"));

         } else if (isMac()) {

            // Mac client app clone urls

            cloneLinks.add(new AppCloneLink(MessageFormat.format(cloneWith, "SourceTree\u2122"),

                  MessageFormat.format("sourcetree://cloneRepo/{0}", primaryUrl),

                  "Atlassian SourceTree\u2122"));

//            cloneLinks.add(new AppCloneLink(

//                  MessageFormat.format(cloneWith, "GitHub\u2122 for Mac"),

//                  MessageFormat.format("github-mac://openRepo/{0}", primaryUrl),

//                  "GitHub\u2122 for Mac"));

         }



         // sparkleshare invite url

         String sparkleshareUrl = getSparkleShareInviteUrl(user, repository);

         if (!StringUtils.isEmpty(sparkleshareUrl)) {

            cloneLinks.add(new AppCloneLink(MessageFormat.format(cloneWith, "SparkleShare\u2122"),

                  sparkleshareUrl, "SparkleShare\u2122", "icon-star"));

         }

         add(createRepositoryIndicators(repository));

      }



      // app clone links

      ListDataProvider<AppCloneLink> appLinks = new ListDataProvider<AppCloneLink>(cloneLinks);

      DataView<AppCloneLink> appCloneLinks = new DataView<AppCloneLink>("appCloneLink", appLinks) {

         private static final long serialVersionUID = 1L;

         int count;

			
         public void populateItem(final Item<AppCloneLink> item) {

            final AppCloneLink appLink = item.getModelObject();

            item.add(new Label("icon", MessageFormat.format("<i class=\"{0}\"></i>", appLink.icon)).setEscapeModelStrings(false));

            LinkPanel linkPanel = new LinkPanel("link", null, appLink.name, appLink.url);

            if (!StringUtils.isEmpty(appLink.tooltip)) {

               WicketUtils.setHtmlTooltip(linkPanel, appLink.tooltip);

      boolean allowAppLinks = app().settings().getBoolean(Keys.web.allowAppCloneLinks, true);

      if (onlyUrls || !canClone || !allowAppLinks) {

         // only display the url(s)

         add(new Label("applicationMenusPanel").setVisible(false));

         return;

      }

      // create the git client application menus

      add(createApplicationMenus("applicationMenusPanel", user, repository, repositoryUrls));

   }



   public String getPrimaryUrl() {

      return primaryUrl == null ? "" : primaryUrl.url;

   }



   protected Fragment createPrimaryUrlPanel(String wicketId, final RepositoryModel repository, List<RepositoryUrl> repositoryUrls) {



      Fragment urlPanel = new Fragment(wicketId, "repositoryUrlFragment", this);

      urlPanel.setRenderBodyOnly(true);



      if (repositoryUrls.size() == 1) {

         //

         // Single repository url, no dropdown menu

         //

         urlPanel.add(new Label("menu").setVisible(false));

      } else {

         //

         // Multiple repository urls, show url drop down menu

         //

         ListDataProvider<RepositoryUrl> urlsDp = new ListDataProvider<RepositoryUrl>(repositoryUrls);

         DataView<RepositoryUrl> repoUrlMenuItems = new DataView<RepositoryUrl>("repoUrls", urlsDp) {

            private static final long serialVersionUID = 1L;



            @Override

            public void populateItem(final Item<RepositoryUrl> item) {

               RepositoryUrl repoUrl = item.getModelObject();

               // repository url

               Fragment fragment = new Fragment("repoUrl", "actionFragment", this);

               Component content = new Label("content", repoUrl.url).setRenderBodyOnly(true);

               WicketUtils.setCssClass(content, "commandMenuItem");

               fragment.add(content);

               item.add(fragment);



               Label permissionLabel = new Label("permission", repoUrl.hasPermission() ? repoUrl.permission.toString() : externalPermission);

               WicketUtils.setPermissionClass(permissionLabel, repoUrl.permission);

               String tooltip = getProtocolPermissionDescription(repository, repoUrl);

               WicketUtils.setHtmlTooltip(permissionLabel, tooltip);

               fragment.add(permissionLabel);

               fragment.add(createCopyFragment(repoUrl.url));

            }

            item.add(linkPanel);

            item.add(new Label("separator", "|").setVisible(count < (cloneLinks.size() - 1)));

            count++;

         };



         Fragment urlMenuFragment = new Fragment("menu", "urlProtocolMenuFragment", this);

         urlMenuFragment.setRenderBodyOnly(true);

         urlMenuFragment.add(new Label("menuText", getString("gb.url")));

         urlMenuFragment.add(repoUrlMenuItems);

         urlPanel.add(urlMenuFragment);

      }



      // access restriction icon and tooltip

      if (repository.isMirror) {

         urlPanel.add(WicketUtils.newImage("accessRestrictionIcon", "mirror_16x16.png",

               getString("gb.isMirror")));

      } else if (app().services().isServingRepositories()) {

         switch (repository.accessRestriction) {

         case NONE:

            urlPanel.add(WicketUtils.newClearPixel("accessRestrictionIcon").setVisible(false));

            break;

         case PUSH:

            urlPanel.add(WicketUtils.newImage("accessRestrictionIcon", "lock_go_16x16.png",

                  getAccessRestrictions().get(repository.accessRestriction)));

            break;

         case CLONE:

            urlPanel.add(WicketUtils.newImage("accessRestrictionIcon", "lock_pull_16x16.png",

                  getAccessRestrictions().get(repository.accessRestriction)));

            break;

         case VIEW:

            urlPanel.add(WicketUtils.newImage("accessRestrictionIcon", "shield_16x16.png",

                  getAccessRestrictions().get(repository.accessRestriction)));

            break;

         default:

            if (repositoryUrls.size() == 1) {

               // force left end cap to have some width

               urlPanel.add(WicketUtils.newBlankIcon("accessRestrictionIcon"));

            } else {

               urlPanel.add(WicketUtils.newClearPixel("accessRestrictionIcon").setVisible(false));

            }

         }

      } else {

         if (repositoryUrls.size() == 1) {

            // force left end cap to have some width

            urlPanel.add(WicketUtils.newBlankIcon("accessRestrictionIcon"));

         } else {

            urlPanel.add(WicketUtils.newClearPixel("accessRestrictionIcon").setVisible(false));

         }

      }



      urlPanel.add(new Label("primaryUrl", primaryUrl.url).setRenderBodyOnly(true));



      Label permissionLabel = new Label("primaryUrlPermission", primaryUrl.hasPermission() ? primaryUrl.permission.toString() : externalPermission);

      String tooltip = getProtocolPermissionDescription(repository, primaryUrl);

      WicketUtils.setHtmlTooltip(permissionLabel, tooltip);

      urlPanel.add(permissionLabel);

      urlPanel.add(createCopyFragment(primaryUrl.url));



      return urlPanel;

   }



   protected Fragment createApplicationMenus(String wicketId, final UserModel user, final RepositoryModel repository, final List<RepositoryUrl> repositoryUrls) {

      final List<GitClientApplication> displayedApps = new ArrayList<GitClientApplication>();

      final String userAgent = ((WebClientInfo) GitBlitWebSession.get().getClientInfo()).getUserAgent();



      if (user.canClone(repository)) {

         for (GitClientApplication app : app().gitblit().getClientApplications()) {

            if (app.isActive && app.allowsPlatform(userAgent)) {

               displayedApps.add(app);

            }

         }

      }



      final String baseURL = WicketUtils.getGitblitURL(RequestCycle.get().getRequest());

      ListDataProvider<GitClientApplication> displayedAppsDp = new ListDataProvider<GitClientApplication>(displayedApps);

      DataView<GitClientApplication> appMenus = new DataView<GitClientApplication>("appMenus", displayedAppsDp) {

         private static final long serialVersionUID = 1L;



         @Override

         public void populateItem(final Item<GitClientApplication> item) {

            final GitClientApplication clientApp = item.getModelObject();



            // filter the urls for the client app

            List<RepositoryUrl> urls = new ArrayList<RepositoryUrl>();

            for (RepositoryUrl repoUrl : repositoryUrls) {

               if (clientApp.minimumPermission == null || !repoUrl.hasPermission()) {

                  // no minimum permission or untracked permissions, assume it is satisfactory

                  if (clientApp.supportsTransport(repoUrl.url)) {

                     urls.add(repoUrl);

                  }

               } else if (repoUrl.permission.atLeast(clientApp.minimumPermission)) {

                  // repo url meets minimum permission requirement

                  if (clientApp.supportsTransport(repoUrl.url)) {

                     urls.add(repoUrl);

                  }

               }

            }



            if (urls.size() == 0) {

               // do not show this app menu because there are no urls

               item.add(new Label("appMenu").setVisible(false));

               return;

            }



            Fragment appMenu = new Fragment("appMenu", "appMenuFragment", this);

            appMenu.setRenderBodyOnly(true);

            item.add(appMenu);



            // menu button

            appMenu.add(new Label("applicationName", clientApp.name));



            // application icon

            Component img;

            if (StringUtils.isEmpty(clientApp.icon)) {

               img = WicketUtils.newClearPixel("applicationIcon").setVisible(false);

            } else {

               if (clientApp.icon.contains("://")) {

                  // external image

                  img = new ExternalImage("applicationIcon", clientApp.icon);

               } else {

                  // context image

                  img = WicketUtils.newImage("applicationIcon", clientApp.icon);

               }

            }

            appMenu.add(img);



            // application menu title, may be a link

            if (StringUtils.isEmpty(clientApp.productUrl)) {

               appMenu.add(new Label("applicationTitle", clientApp.toString()));

            } else {

               appMenu.add(new LinkPanel("applicationTitle", null, clientApp.toString(), clientApp.productUrl, true));

            }



            // brief application description

            if (StringUtils.isEmpty(clientApp.description)) {

               appMenu.add(new Label("applicationDescription").setVisible(false));

            } else {

               appMenu.add(new Label("applicationDescription", clientApp.description));

            }



            // brief application legal info, copyright, license, etc

            if (StringUtils.isEmpty(clientApp.legal)) {

               appMenu.add(new Label("applicationLegal").setVisible(false));

            } else {

               appMenu.add(new Label("applicationLegal", clientApp.legal));

            }



            // a nested repeater for all action items

            ListDataProvider<RepositoryUrl> urlsDp = new ListDataProvider<RepositoryUrl>(urls);

            DataView<RepositoryUrl> actionItems = new DataView<RepositoryUrl>("actionItems", urlsDp) {

               private static final long serialVersionUID = 1L;



               @Override

               public void populateItem(final Item<RepositoryUrl> repoLinkItem) {

                  RepositoryUrl repoUrl = repoLinkItem.getModelObject();

                  Fragment fragment = new Fragment("actionItem", "actionFragment", this);

                  fragment.add(createPermissionBadge("permission", repoUrl));



                  if (!StringUtils.isEmpty(clientApp.cloneUrl)) {

                     // custom registered url

                     String url = substitute(clientApp.cloneUrl, repoUrl.url, baseURL, user.username, repository.name);

                     fragment.add(new LinkPanel("content", "applicationMenuItem", getString("gb.clone") + " " + repoUrl.url, url));

                     repoLinkItem.add(fragment);

                     fragment.add(new Label("copyFunction").setVisible(false));

                  } else if (!StringUtils.isEmpty(clientApp.command)) {

                     // command-line

                     String command = substitute(clientApp.command, repoUrl.url, baseURL, user.username, repository.name);

                     Label content = new Label("content", command);

                     WicketUtils.setCssClass(content, "commandMenuItem");

                     fragment.add(content);

                     repoLinkItem.add(fragment);



                     // copy function for command

                     fragment.add(createCopyFragment(command));

                  }

               }};

               appMenu.add(actionItems);

         }

      };

      add(appCloneLinks);



      Fragment applicationMenus = new Fragment(wicketId, "applicationMenusFragment", this);

      applicationMenus.add(appMenus);

      return applicationMenus;

   }

	
   public String getPrimaryUrl() {

      return primaryUrl;



   protected String substitute(String pattern, String repoUrl, String baseUrl, String username, String repository) {

      return pattern.replace("${repoUrl}", repoUrl).replace("${baseUrl}", baseUrl).replace("${username}", username).replace("${repository}", repository);

   }

	
   protected String getRepositoryUrl(RepositoryModel repository) {

      StringBuilder sb = new StringBuilder();

      sb.append(WicketUtils.getGitblitURL(RequestCycle.get().getRequest()));

      sb.append(Constants.GIT_PATH);

      sb.append(repository.name);

		
      // inject username into repository url if authentication is required

      if (repository.accessRestriction.exceeds(AccessRestrictionType.NONE)

            && GitBlitWebSession.get().isLoggedIn()) {

         String username = GitBlitWebSession.get().getUsername();

         sb.insert(sb.indexOf("://") + 3, username + "@");

      }

      return sb.toString();



   protected Label createPermissionBadge(String wicketId, RepositoryUrl repoUrl) {

      Label permissionLabel = new Label(wicketId, repoUrl.hasPermission() ? repoUrl.permission.toString() : externalPermission);

      WicketUtils.setPermissionClass(permissionLabel, repoUrl.permission);

      String tooltip = getProtocolPermissionDescription(repository, repoUrl);

      WicketUtils.setHtmlTooltip(permissionLabel, tooltip);

      return permissionLabel;

   }

	
   protected Component createGitDaemonUrlPanel(String wicketId, UserModel user, RepositoryModel repository) {

      int gitDaemonPort = GitBlit.getInteger(Keys.git.daemonPort, 0);

      if (gitDaemonPort > 0 && user.canClone(repository)) {

         String servername = ((WebRequest) getRequest()).getHttpServletRequest().getServerName();

         String gitDaemonUrl;

         if (gitDaemonPort == 9418) {

            // standard port

            gitDaemonUrl = MessageFormat.format("git://{0}/{1}", servername, repository.name);

         } else {

            // non-standard port

            gitDaemonUrl = MessageFormat.format("git://{0}:{1,number,0}/{2}", servername, gitDaemonPort, repository.name);

         }

			
         AccessPermission gitDaemonPermission = user.getRepositoryPermission(repository).permission;;

         if (gitDaemonPermission.atLeast(AccessPermission.CLONE)) {

            if (repository.accessRestriction.atLeast(AccessRestrictionType.CLONE)) {

               // can not authenticate clone via anonymous git protocol

               gitDaemonPermission = AccessPermission.NONE;

            } else if (repository.accessRestriction.atLeast(AccessRestrictionType.PUSH)) {

               // can not authenticate push via anonymous git protocol

               gitDaemonPermission = AccessPermission.CLONE;

            } else {

               // normal user permission

            }

         }

			
         if (AccessPermission.NONE.equals(gitDaemonPermission)) {

            // repository prohibits all anonymous access

            return new Label(wicketId).setVisible(false);

         } else {

            // repository allows some form of anonymous access

            return new DetailedRepositoryUrlPanel(wicketId, getLocalizer(), this, repository.name, gitDaemonUrl, gitDaemonPermission);

         }



   protected Fragment createCopyFragment(String text) {

      if (app().settings().getBoolean(Keys.web.allowFlashCopyToClipboard, true)) {

         // clippy: flash-based copy & paste

         Fragment copyFragment = new Fragment("copyFunction", "clippyPanel", this);

         String baseUrl = WicketUtils.getGitblitURL(getRequest());

         ShockWaveComponent clippy = new ShockWaveComponent("clippy", baseUrl + "/clippy.swf");

         clippy.setValue("flashVars", "text=" + StringUtils.encodeURL(text));

         copyFragment.add(clippy);

         return copyFragment;

      } else {

         // git daemon is not running

         return new Label(wicketId).setVisible(false);

         // javascript: manual copy & paste with modal browser prompt dialog

         Fragment copyFragment = new Fragment("copyFunction", "jsPanel", this);

         ContextImage img = WicketUtils.newImage("copyIcon", "clippy.png");

         img.add(new JavascriptTextPrompt("onclick", "Copy to Clipboard (Ctrl+C, Enter)", text));

         copyFragment.add(img);

         return copyFragment;

      }

   }



   protected String getSparkleShareInviteUrl(UserModel user, RepositoryModel repository) {

      if (repository.isBare && repository.isSparkleshared()) {

         String username = null;

         if (UserModel.ANONYMOUS != user) {

            username = user.username;

         }

         if (GitBlit.getBoolean(Keys.git.enableGitServlet, true) || (GitBlit.getInteger(Keys.git.daemonPort, 0) > 0)) {

            // Gitblit as server

            // ensure user can rewind

            if (user.canRewindRef(repository)) {

               String baseURL = WicketUtils.getGitblitURL(RequestCycle.get().getRequest());

               return SparkleShareInviteServlet.asLink(baseURL, repository.name, username);

   protected String getProtocolPermissionDescription(RepositoryModel repository,

         RepositoryUrl repoUrl) {

      if (!urlPermissionsMap.containsKey(repoUrl.url)) {

         String note;

         if (repoUrl.hasPermission()) {

            note = null;

            String key;

            switch (repoUrl.permission) {

            case OWNER:

            case REWIND:

               key = "gb.rewindPermission";

               break;

            case DELETE:

               key = "gb.deletePermission";

               break;

            case CREATE:

               key = "gb.createPermission";

               break;

            case PUSH:

               key = "gb.pushPermission";

               break;

            case CLONE:

               key = "gb.clonePermission";

               break;

            default:

               key = null;

               note = getString("gb.viewAccess");

               break;

            }



            if (note == null) {

               String pattern = getString(key);

               String description = MessageFormat.format(pattern, repoUrl.permission.toString());

               note = description;

            }

         } else {

            // Gitblit as viewer, assume RW+ permission

            String baseURL = WicketUtils.getGitblitURL(RequestCycle.get().getRequest());

            return SparkleShareInviteServlet.asLink(baseURL, repository.name, username);

            String protocol;

            int protocolIndex = repoUrl.url.indexOf("://");

            if (protocolIndex > -1) {

               // explicit protocol specified

               protocol = repoUrl.url.substring(0, protocolIndex);

            } else {

               // implicit SSH url

               protocol = "ssh";

            }

            note = MessageFormat.format(getString("gb.externalPermissions"), protocol);

         }

         urlPermissionsMap.put(repoUrl.url, note);

      }

      return urlPermissionsMap.get(repoUrl.url);

   }



   protected Map<AccessRestrictionType, String> getAccessRestrictions() {

      if (accessRestrictionsMap == null) {

         accessRestrictionsMap = new HashMap<AccessRestrictionType, String>();

         for (AccessRestrictionType type : AccessRestrictionType.values()) {

            switch (type) {

            case NONE:

               accessRestrictionsMap.put(type, getString("gb.notRestricted"));

               break;

            case PUSH:

               accessRestrictionsMap.put(type, getString("gb.pushRestricted"));

               break;

            case CLONE:

               accessRestrictionsMap.put(type, getString("gb.cloneRestricted"));

               break;

            case VIEW:

               accessRestrictionsMap.put(type, getString("gb.viewRestricted"));

               break;

            }

         }

      }

      return null;

      return accessRestrictionsMap;

   }

	
   static class AppCloneLink implements Serializable {

		
      private static final long serialVersionUID = 1L;

		
      final String name;

      final String url;

      final String tooltip;

      final String icon;

		
      public AppCloneLink(String name, String url, String tooltip) {

         this(name, url, tooltip, "icon-download");



   protected Component createRepositoryIndicators(RepositoryModel repository) {

      Fragment fragment = new Fragment("repositoryIndicators", "indicatorsFragment", this);

      if (repository.isBare) {

         fragment.add(new Label("workingCopyIndicator").setVisible(false));

      } else {

         Fragment wc = new Fragment("workingCopyIndicator", "workingCopyFragment", this);

         Label lbl = new Label("workingCopy", getString("gb.workingCopy"));

         WicketUtils.setHtmlTooltip(lbl,  getString("gb.workingCopyWarning"));

         wc.add(lbl);

         fragment.add(wc);

      }

		
      public AppCloneLink(String name, String url, String tooltip, String icon) {

         this.name = name;

         this.url = url;

         this.tooltip = tooltip;

         this.icon = icon;



      boolean allowForking = app().settings().getBoolean(Keys.web.allowForking, true);

      if (!allowForking || user == null || !user.isAuthenticated) {

         // must be logged-in to fork, hide all fork controls

         fragment.add(new Label("forksProhibitedIndicator").setVisible(false));

      } else {

         String fork = app().repositories().getFork(user.username, repository.name);

         boolean hasFork = fork != null;

         boolean canFork = user.canFork(repository);



         if (hasFork || !canFork) {

            if (user.canFork() && !repository.allowForks) {

               // show forks prohibited indicator

               Fragment wc = new Fragment("forksProhibitedIndicator", "forksProhibitedFragment", this);

               Label lbl = new Label("forksProhibited", getString("gb.forksProhibited"));

               WicketUtils.setHtmlTooltip(lbl,  getString("gb.forksProhibitedWarning"));

               wc.add(lbl);

               fragment.add(wc);

            } else {

               // can not fork, no need for forks prohibited indicator

               fragment.add(new Label("forksProhibitedIndicator").setVisible(false));

            }

         } else if (canFork) {

            // can fork and we do not have one

            fragment.add(new Label("forksProhibitedIndicator").setVisible(false));

         }

      }

      return fragment;

   }

}