/*
|
* 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.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.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.AccessPermission;
|
import com.gitblit.Constants.AccessRestrictionType;
|
import com.gitblit.Keys;
|
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 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);
|
this.onlyUrls = onlyUrls;
|
this.user = user == null ? UserModel.ANONYMOUS : user;
|
this.repository = repository;
|
this.urlPermissionsMap = new HashMap<String, String>();
|
}
|
|
@Override
|
protected void onInitialize() {
|
super.onInitialize();
|
|
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(createRepositoryIndicators(repository));
|
}
|
|
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));
|
}
|
};
|
|
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);
|
}
|
};
|
|
Fragment applicationMenus = new Fragment(wicketId, "applicationMenusFragment", this);
|
applicationMenus.add(appMenus);
|
return applicationMenus;
|
}
|
|
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 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 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 {
|
// 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 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 {
|
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 accessRestrictionsMap;
|
}
|
|
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);
|
}
|
|
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;
|
}
|
}
|
