/*
|
* Copyright 2011 gitblit.com.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
package com.gitblit.wicket.panels;
|
|
import java.io.Serializable;
|
import java.text.MessageFormat;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
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.UserModel;
|
import com.gitblit.utils.StringUtils;
|
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 RepoUrl primaryUrl;
|
|
public RepositoryUrlPanel(String wicketId, boolean onlyPrimary, UserModel user,
|
final RepositoryModel repository, Localizer localizer, Component owner) {
|
super(wicketId);
|
if (user == null) {
|
user = UserModel.ANONYMOUS;
|
}
|
List<RepoUrl> repositoryUrls = new ArrayList<RepoUrl>();
|
|
// http/https url
|
if (GitBlit.getBoolean(Keys.git.enableGitServlet, true)) {
|
AccessPermission permission = user.getRepositoryPermission(repository).permission;
|
if (permission.exceeds(AccessPermission.NONE)) {
|
repositoryUrls.add(new RepoUrl(getRepositoryUrl(repository), permission));
|
}
|
}
|
|
// git daemon url
|
String gitDaemonUrl = getGitDaemonUrl(user, repository);
|
if (!StringUtils.isEmpty(gitDaemonUrl)) {
|
AccessPermission permission = getGitDaemonAccessPermission(user, repository);
|
if (permission.exceeds(AccessPermission.NONE)) {
|
repositoryUrls.add(new RepoUrl(gitDaemonUrl, permission));
|
}
|
}
|
|
// add all other urls
|
for (String url : GitBlit.self().getOtherCloneUrls(repository.name, UserModel.ANONYMOUS.equals(user) ? "" : user.username)) {
|
repositoryUrls.add(new RepoUrl(url, null));
|
}
|
|
// grab primary url from the top of the list
|
primaryUrl = repositoryUrls.size() == 0 ? null : repositoryUrls.get(0);
|
|
add(new DetailedRepositoryUrlPanel("repositoryPrimaryUrl", localizer, owner,
|
repository.name, primaryUrl == null ? "" : primaryUrl.url,
|
primaryUrl == null ? null : primaryUrl.permission));
|
|
if (onlyPrimary) {
|
// only displaying the primary url
|
add(new Label("urlMenus").setVisible(false));
|
return;
|
}
|
|
final String clonePattern = localizer.getString("gb.cloneUrl", owner);
|
final String visitSitePattern = localizer.getString("gb.visitSite", owner);
|
|
GitClientApplication URLS = new GitClientApplication();
|
URLS.name = "URLs";
|
URLS.command = "{0}";
|
URLS.attribution = "Repository URLs";
|
URLS.isApplication = false;
|
URLS.isActive = true;
|
|
GitClientApplication GIT = new GitClientApplication();
|
GIT.name = "Git";
|
GIT.command = "git clone {0}";
|
GIT.productUrl = "http://git-scm.org";
|
GIT.attribution = "Git Syntax";
|
GIT.isApplication = false;
|
GIT.isActive = true;
|
|
final List<GitClientApplication> clientApps = new ArrayList<GitClientApplication>();
|
clientApps.add(URLS);
|
clientApps.add(GIT);
|
|
final String userAgent = ((WebClientInfo) GitBlitWebSession.get().getClientInfo()).getUserAgent();
|
boolean allowAppLinks = GitBlit.getBoolean(Keys.web.allowAppCloneLinks, true);
|
if (user.canClone(repository)) {
|
for (GitClientApplication app : GitBlit.self().getClientApplications()) {
|
if (app.isActive && app.allowsPlatform(userAgent) && (!app.isApplication || (app.isApplication && allowAppLinks))) {
|
clientApps.add(app);
|
}
|
}
|
|
// sparkleshare invite url
|
String sparkleshareUrl = getSparkleShareInviteUrl(user, repository);
|
if (!StringUtils.isEmpty(sparkleshareUrl) && allowAppLinks) {
|
GitClientApplication link = new GitClientApplication();
|
link.name = "SparkleShare";
|
link.cloneUrl = sparkleshareUrl;
|
link.attribution = "SparkleShare\u2122";
|
link.platforms = new String [] { "windows", "macintosh", "linux" };
|
link.productUrl = "http://sparkleshare.org";
|
link.isApplication = true;
|
link.isActive = true;
|
clientApps.add(link);
|
}
|
}
|
|
final ListDataProvider<RepoUrl> repoUrls = new ListDataProvider<RepoUrl>(repositoryUrls);
|
|
// app clone links
|
ListDataProvider<GitClientApplication> appLinks = new ListDataProvider<GitClientApplication>(clientApps);
|
DataView<GitClientApplication> urlMenus = new DataView<GitClientApplication>("urlMenus", appLinks) {
|
private static final long serialVersionUID = 1L;
|
|
public void populateItem(final Item<GitClientApplication> item) {
|
final GitClientApplication cloneLink = item.getModelObject();
|
item.add(new Label("productName", cloneLink.name));
|
|
// a nested repeater for all repo links
|
DataView<RepoUrl> repoLinks = new DataView<RepoUrl>("repoLinks", repoUrls) {
|
private static final long serialVersionUID = 1L;
|
|
public void populateItem(final Item<RepoUrl> repoLinkItem) {
|
RepoUrl repoUrl = repoLinkItem.getModelObject();
|
if (!StringUtils.isEmpty(cloneLink.cloneUrl)) {
|
// custom registered url
|
Fragment fragment = new Fragment("repoLink", "linkFragment", this);
|
String name;
|
if (repoUrl.permission != null) {
|
name = MessageFormat.format("{0} ({1})", repoUrl.url, repoUrl.permission);
|
} else {
|
name = repoUrl.url;
|
}
|
String url = MessageFormat.format(cloneLink.cloneUrl, repoUrl);
|
fragment.add(new LinkPanel("content", null, MessageFormat.format(clonePattern, name), url));
|
repoLinkItem.add(fragment);
|
String tooltip = getProtocolPermissionDescription(repository, repoUrl);
|
WicketUtils.setHtmlTooltip(fragment, tooltip);
|
} else if (!StringUtils.isEmpty(cloneLink.command)) {
|
// command-line
|
Fragment fragment = new Fragment("repoLink", "commandFragment", this);
|
WicketUtils.setCssClass(fragment, "repositoryUrlMenuItem");
|
String command = MessageFormat.format(cloneLink.command, repoUrl);
|
fragment.add(new Label("content", command));
|
repoLinkItem.add(fragment);
|
String tooltip = getProtocolPermissionDescription(repository, repoUrl);
|
WicketUtils.setHtmlTooltip(fragment, tooltip);
|
|
// copy function for command
|
if (GitBlit.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(command));
|
copyFragment.add(clippy);
|
fragment.add(copyFragment);
|
} else {
|
// 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)", command));
|
copyFragment.add(img);
|
fragment.add(copyFragment);
|
}
|
}
|
}};
|
item.add(repoLinks);
|
|
item.add(new Label("productAttribution", cloneLink.attribution));
|
if (!StringUtils.isEmpty(cloneLink.productUrl)) {
|
LinkPanel productlinkPanel = new LinkPanel("productLink", null,
|
MessageFormat.format(visitSitePattern, cloneLink.name), cloneLink.productUrl, true);
|
item.add(productlinkPanel);
|
} else {
|
item.add(new Label("productLink").setVisible(false));
|
}
|
}
|
};
|
add(urlMenus);
|
}
|
|
public String getPrimaryUrl() {
|
return primaryUrl == null ? "" : primaryUrl.url;
|
}
|
|
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 String getGitDaemonUrl(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);
|
}
|
return gitDaemonUrl;
|
}
|
return null;
|
}
|
|
protected AccessPermission getGitDaemonAccessPermission(UserModel user, RepositoryModel repository) {
|
int gitDaemonPort = GitBlit.getInteger(Keys.git.daemonPort, 0);
|
if (gitDaemonPort > 0 && user.canClone(repository)) {
|
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
|
}
|
}
|
return gitDaemonPermission;
|
}
|
return AccessPermission.NONE;
|
}
|
|
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);
|
}
|
} else {
|
// Gitblit as viewer, assume RW+ permission
|
String baseURL = WicketUtils.getGitblitURL(RequestCycle.get().getRequest());
|
return SparkleShareInviteServlet.asLink(baseURL, repository.name, username);
|
}
|
}
|
return null;
|
}
|
|
protected String getProtocolPermissionDescription(RepositoryModel repository, RepoUrl repoUrl) {
|
String protocol = repoUrl.url.substring(0, repoUrl.url.indexOf("://"));
|
String note;
|
if (repoUrl.permission == null) {
|
note = MessageFormat.format(getString("gb.externalPermissions"), protocol, repository.name);
|
} else {
|
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());
|
String permissionPattern = getString("gb.yourProtocolPermissionIs");
|
note = MessageFormat.format(permissionPattern, protocol.toUpperCase(), repository, description);
|
}
|
}
|
return note;
|
}
|
|
private class RepoUrl implements Serializable {
|
|
private static final long serialVersionUID = 1L;
|
|
final String url;
|
final AccessPermission permission;
|
|
RepoUrl(String url, AccessPermission permission) {
|
this.url = url;
|
this.permission = permission;
|
}
|
|
@Override
|
public String toString() {
|
return url;
|
}
|
}
|
}
|
