refs:3772: SAI - Create a github project importer

https://support.d4science.org/issues/3772

Updated card on wizard

git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/portlets/widgets/github-connector@129130 82a268e6-3cf1-43bd-a215-b396298e98cf
master
Giancarlo Panichi 8 years ago
parent 233c381937
commit d0918a9f60

@ -86,6 +86,9 @@ public class GitHubConnectorController {
});
}
private void bind() {

@ -1,151 +1,104 @@
package org.gcube.portlets.widgets.githubconnector.client;
import org.gcube.portlets.widgets.githubconnector.client.util.GWTMessages;
import org.gcube.portlets.widgets.githubconnector.client.wizard.WizardCard;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredentialType;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialAnonymous;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialLogin;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialOAuth2;
import com.google.gwt.core.shared.GWT;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.ui.DecoratorPanel;
import com.google.gwt.user.client.ui.CheckBox;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.RadioButton;
import com.google.gwt.user.client.ui.SimplePanel;
import com.google.gwt.user.client.ui.TabLayoutPanel;
import com.google.gwt.user.client.ui.TextBox;
public class GitHubConnectorCredentialCard extends WizardCard {
private GitHubCredential gitHubCredential;
private GitHubCredentialType selected;
private SimplePanel simplePanel;
private FlexTable layout;
private TabLayoutPanel tabPanel;
private TextBox userName;
private TextBox password;
private TextBox token;
//private DecoratorPanel decPanel;
private CheckBox anonymousCheck;
// private DecoratorPanel decPanel;
public GitHubConnectorCredentialCard() {
super("Credential", "Select the credentials to use");
selected = GitHubCredentialType.Anonymous;
simplePanel = new SimplePanel();
// Form
layout = new FlexTable();
layout.setCellSpacing(16);
tabPanel = new TabLayoutPanel(2.5, Unit.EM);
tabPanel.setAnimationDuration(1000);
tabPanel.setAnimationVertical(true);
tabPanel.getElement().getStyle().setMarginBottom(10.0, Unit.PX);
tabPanel.setHeight("120px");
tabPanel.setWidth("265px");
// Add Login Tab
SimplePanel loginContainer = new SimplePanel();
userName = new TextBox();
userName.setWidth("166px");
userName.setEnabled(false);
password = new TextBox();
token = new TextBox();
password.setWidth("166px");
password.setEnabled(false);
anonymousCheck = new CheckBox("Anonymous");
anonymousCheck.setValue(true);
anonymousCheck.ensureDebugId("credentialCheckBoxAnonymous");
anonymousCheck.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
if (anonymousCheck.getValue()) {
userName.setEnabled(false);
password.setEnabled(false);
userName.setValue("");
password.setValue("");
} else {
userName.setEnabled(true);
password.setEnabled(true);
userName.setValue("");
password.setValue("");
// Add some standard form options
HorizontalPanel hPanel = new HorizontalPanel();
hPanel.setSpacing(10);
for (GitHubCredentialType type : GitHubCredentialType.values()) {
RadioButton radioButton = new RadioButton("credentialType",
type.getLabel());
radioButton.getElement().setAttribute("itemId", type.name());
radioButton.ensureDebugId("radioButton-credentialType-"
+ type.name());
radioButton
.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
@Override
public void onValueChange(
ValueChangeEvent<Boolean> event) {
if (event.getValue()) {
RadioButton radioButton = (RadioButton) event
.getSource();
String selectedCredential = radioButton
.getElement().getAttribute("itemId");
GWT.log("Selected Credential: "
+ selectedCredential);
if (selectedCredential != null) {
selected = GitHubCredentialType
.valueOf(selectedCredential);
if (selected != null) {
switch (selected) {
case Anonymous:
GWT.log("Anonymous");
setAnonymous();
break;
case Login:
GWT.log("Login");
setLogin();
break;
case OAuth2:
GWT.log("OAuth2");
setOAuth2();
break;
default:
GWT.log("OAuth2");
setAnonymous();
break;
}
} else {
selected = GitHubCredentialType.Anonymous;
setAnonymous();
}
}
}
}
}
});
if (type.compareTo(GitHubCredentialType.Anonymous) == 0) {
radioButton.setValue(true);
}
});
hPanel.add(radioButton);
}
layout.setHTML(1, 0, "Type:");
layout.setWidget(1, 1, hPanel);
FlexTable loginFlexTable = new FlexTable();
loginFlexTable.setCellSpacing(16);
loginFlexTable.setHTML(1, 0, "Anonymous:");
loginFlexTable.setWidget(1, 1, anonymousCheck);
// Wrap the content in a DecoratorPanel
//decPanel = new DecoratorPanel();
//decPanel.setWidget(layout);
loginFlexTable.setHTML(2, 0, "User:");
loginFlexTable.setWidget(2, 1, userName);
simplePanel.add(layout);
setContent(simplePanel);
}
loginFlexTable.setHTML(3, 0, "Password:");
loginFlexTable.setWidget(3, 1, password);
private void setAnonymous() {
if (selected.compareTo(GitHubCredentialType.Anonymous) != 0) {
for (int i = 1; i <= layout.getRowCount(); i++) {
layout.removeRow(i);
}
}
loginContainer.add(loginFlexTable);
tabPanel.add(loginContainer, "Login");
}
// Add OAuth2 Tab
SimplePanel oAuth2Container = new SimplePanel();
token = new TextBox();
token.setWidth("200px");
private void setOAuth2() {
if (selected.compareTo(GitHubCredentialType.OAuth2) != 0) {
for (int i = 1; i <= layout.getRowCount(); i++) {
layout.removeRow(i);
}
layout.setHTML(2, 0, "Token:");
layout.add(token);
}
FlexTable oAuth2FlexTable = new FlexTable();
oAuth2FlexTable.setCellSpacing(16);
oAuth2FlexTable.setHTML(1, 0, "Token:");
oAuth2FlexTable.setWidget(1, 1, token);
}
oAuth2Container.add(oAuth2FlexTable);
tabPanel.add(oAuth2Container, "OAuth2");
private void setLogin() {
if (selected.compareTo(GitHubCredentialType.Login) != 0) {
for (int i = 1; i <= layout.getRowCount(); i++) {
layout.removeRow(i);
}
layout.setHTML(2, 0, "User:");
layout.add(userName);
tabPanel.selectTab(0);
tabPanel.ensureDebugId("credentialTabPanel");
layout.setHTML(3, 0, "Password:");
layout.add(password);
}
setContent(tabPanel);
}
@ -154,12 +107,9 @@ public class GitHubConnectorCredentialCard extends WizardCard {
Command sayNextCard = new Command() {
public void execute() {
try {
GWT.log("NextCard");
getWizardWindow().nextCard();
} catch (Exception e) {
GWT.log("sayNextCard :" + e.getLocalizedMessage());
}
checkData();
}
};
@ -171,6 +121,7 @@ public class GitHubConnectorCredentialCard extends WizardCard {
getWizardWindow().previousCard();
} catch (Exception e) {
GWT.log("sayPreviousCard :" + e.getLocalizedMessage());
e.printStackTrace();
}
}
};
@ -184,4 +135,67 @@ public class GitHubConnectorCredentialCard extends WizardCard {
setNextButtonVisible(true);
}
private void checkData() {
int selectedIndex = tabPanel.getSelectedIndex();
if (selectedIndex > -1) {
GWT.log("Selected Tab:" + selectedIndex);
if (selectedIndex == 0) {
if (anonymousCheck.getValue()) {
GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
wiz.getGitHubCloneSession().setGitHubCredential(
new GitHubCredentialAnonymous());
goNext();
} else {
String userN = userName.getValue();
if (userN == null || userN.isEmpty()) {
GWTMessages.alert("Attention", "Enter a user name!");
} else {
String pwd = password.getValue();
if (pwd == null || pwd.isEmpty()) {
GWTMessages.alert("Attention",
"Enter a user password!");
} else {
GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
wiz.getGitHubCloneSession().setGitHubCredential(
new GitHubCredentialLogin(userN, pwd));
goNext();
}
}
}
} else {
if (selectedIndex == 1) {
String tk = token.getValue();
if (tk == null || tk.isEmpty()) {
GWTMessages.alert("Attention", "Enter a token!");
} else {
GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
wiz.getGitHubCloneSession().setGitHubCredential(
new GitHubCredentialOAuth2(tk));
goNext();
}
} else {
GWTMessages.alert("Attention", "Select a valid tab!");
}
}
}
}
private void goNext() {
try {
GWT.log("NextCard: GitHubConnectorRepositorySelectionCard");
GitHubConnectorRepositorySelectionCard card = new GitHubConnectorRepositorySelectionCard();
getWizardWindow().addCard(card);
getWizardWindow().nextCard();
} catch (Throwable e) {
GWT.log("sayNextCard :" + e.getLocalizedMessage());
e.printStackTrace();
}
}
}

@ -51,7 +51,7 @@ public class GitHubConnectorDialog extends DialogBox implements ClickHandler {
@Override
public void onClick(ClickEvent event) {
// TODO Auto-generated method stub
//TODO
}
};

@ -83,7 +83,7 @@ public class GitHubConnectorManager implements EntryPoint {
wizardWindow.show();
*/
GitHubConnectorWizard wizard=new GitHubConnectorWizard();
GitHubConnectorWizard wizard=new GitHubConnectorWizard("0cfde9e2-a6f0-451f-a048-adbd42d7d57f");
wizard.show();

@ -0,0 +1,216 @@
package org.gcube.portlets.widgets.githubconnector.client;
import java.util.ArrayList;
import org.gcube.portlets.widgets.githubconnector.client.resource.GCResources;
import org.gcube.portlets.widgets.githubconnector.client.rpc.GitHubConnectorServiceAsync;
import org.gcube.portlets.widgets.githubconnector.client.util.GWTMessages;
import org.gcube.portlets.widgets.githubconnector.client.wizard.WizardCard;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ExpiredSessionServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import com.google.gwt.core.shared.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.FlexTable.FlexCellFormatter;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.ListBox;
import com.google.gwt.user.client.ui.PushButton;
import com.google.gwt.user.client.ui.SimplePanel;
import com.google.gwt.user.client.ui.TextBox;
public class GitHubConnectorRepositorySelectionCard extends WizardCard {
private TextBox repositoryOwner;
private ListBox repositoryName;
// private DecoratorPanel decPanel;
public GitHubConnectorRepositorySelectionCard() {
super("Repository", "Enter a owner for select repository");
try {
SimplePanel repositorySelectionPanel = new SimplePanel();
repositoryOwner = new TextBox();
repositoryName = new ListBox();
repositoryName.setWidth("176px");
repositoryName.setEnabled(false);
repositoryName.ensureDebugId("repositoryNameList");
repositorySelectionPanel.setStyleName(GCResources.INSTANCE
.wizardCSS().getCardPanel());
ClickHandler searchRepositoryClickHandler = new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
retrieveRepositories();
}
};
PushButton searchRepository = new PushButton(new Image(
GCResources.INSTANCE.search16()),
searchRepositoryClickHandler);
// Form
FlexTable layout = new FlexTable();
layout.setCellSpacing(10);
FlexTable loginFlexTable = new FlexTable();
loginFlexTable.setStyleName(GCResources.INSTANCE.wizardCSS()
.getCardPanelContent());
loginFlexTable.setCellSpacing(16);
FlexCellFormatter cellFormatter = layout.getFlexCellFormatter();
loginFlexTable.setHTML(1, 0, "Owner:");
loginFlexTable.setWidget(1, 1, repositoryOwner);
loginFlexTable.setWidget(1, 2, searchRepository);
loginFlexTable.setHTML(2, 0, "Name:");
loginFlexTable.setWidget(2, 1, repositoryName);
cellFormatter.setColSpan(2, 1, 2);
repositorySelectionPanel.add(loginFlexTable);
setContent(repositorySelectionPanel);
} catch (Exception e) {
GWT.log("Error: " + e.getLocalizedMessage());
e.printStackTrace();
}
}
private void retrieveRepositories() {
String repOwner = repositoryOwner.getValue();
if (repOwner == null || repOwner.isEmpty()) {
GWTMessages.alert("Attention", "Enter a owner!");
} else {
final GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
GitHubConnectorServiceAsync.INSTANCE.getRepositories(repOwner, wiz
.getGitHubCloneSession().getGitHubCredential(),
new AsyncCallback<ArrayList<GitHubRepository>>() {
@Override
public void onFailure(Throwable caught) {
GWT.log("Error retrieving repositories: "
+ caught.getMessage());
if (caught instanceof ExpiredSessionServiceException) {
GWTMessages.alert("Error", "Expired Session");
wiz.sessionExpiredShowDelayed();
} else {
GWTMessages.alert(
"Error",
"Retrieving repositories: "
+ caught.getLocalizedMessage());
}
}
@Override
public void onSuccess(
ArrayList<GitHubRepository> repositories) {
repositoryName.clear();
for (GitHubRepository repository : repositories) {
repositoryName.addItem(repository.getName());
}
repositoryName.setEnabled(true);
}
});
}
}
@Override
public void setup() {
Command sayNextCard = new Command() {
public void execute() {
checkData();
}
};
Command sayPreviousCard = new Command() {
public void execute() {
try {
GWT.log("PreviousCard");
getWizardWindow().setNextButtonToDefault();
getWizardWindow().previousCard();
} catch (Exception e) {
GWT.log("sayPreviousCard :" + e.getLocalizedMessage());
}
}
};
getWizardWindow().setPreviousButtonCommand(sayPreviousCard);
getWizardWindow().setNextButtonCommand(sayNextCard);
getWizardWindow().setNextButtonToFinish();
setEnableBackButton(true);
setBackButtonVisible(true);
setEnableNextButton(true);
setNextButtonVisible(true);
}
private void checkData() {
String repoOwner=repositoryOwner.getValue();
if (repoOwner == null || repoOwner.isEmpty()) {
GWTMessages.alert("Attention", "Enter a repository owner!");
} else {
String repoName=repositoryName.getSelectedItemText();
if (repoName == null || repoName.isEmpty()) {
GWTMessages.alert("Attention", "Select a repository name!");
} else {
GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
wiz.getGitHubCloneSession().setRepositoryName(repoName);
wiz.getGitHubCloneSession().setRepositoryOwner(repoOwner);
callCloneForRepository();
}
}
}
private void callCloneForRepository() {
final GitHubConnectorWizard wiz = (GitHubConnectorWizard) getWizardWindow();
GitHubConnectorServiceAsync.INSTANCE.cloneRepository(wiz.getGitHubCloneSession(), new AsyncCallback<Void>() {
@Override
public void onFailure(Throwable caught) {
GWT.log("Error in clone repository: "
+ caught.getMessage());
if (caught instanceof ExpiredSessionServiceException) {
GWTMessages.alert("Error", "Expired Session");
wiz.sessionExpiredShowDelayed();
} else {
GWTMessages.alert(
"Error",
"In clone repository: "
+ caught.getLocalizedMessage());
}
}
@Override
public void onSuccess(Void result) {
goNext();
}
});
}
private void goNext() {
try {
GWT.log("NextCard");
getWizardWindow().close(false);
} catch (Exception e) {
GWT.log("sayNextCard :" + e.getLocalizedMessage());
}
}
}

@ -1,8 +1,11 @@
package org.gcube.portlets.widgets.githubconnector.client;
import org.gcube.portlets.widgets.githubconnector.client.wizard.WizardWindow;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubCloneSession;
import org.gcube.portlets.widgets.sessionchecker.client.CheckSession;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Timer;
/**
*
@ -12,19 +15,47 @@ import com.google.gwt.core.client.GWT;
*/
public class GitHubConnectorWizard extends WizardWindow {
public GitHubConnectorWizard() {
private GitHubCloneSession gitHubCloneSession;
public GitHubConnectorWizard(String destinationFolderId) {
super("GitHub Connector");
GWT.log("GitHubConnectorWizard");
GWT.log("GitHubConnectorWizard: " + destinationFolderId);
checkSession();
gitHubCloneSession = new GitHubCloneSession(destinationFolderId);
create();
}
private void create() {
/*ApplyTableRuleSession applyTableRuleSession = new ApplyTableRuleSession();
applyTableRuleSession.setTrId(trId);*/
GitHubConnectorCredentialCard CredentialCard = new GitHubConnectorCredentialCard();
addCard(CredentialCard);
CredentialCard.setup();
}
public GitHubCloneSession getGitHubCloneSession() {
return gitHubCloneSession;
}
private void checkSession() {
// if you do not need to something when the session expire
CheckSession.getInstance().startPolling();
}
private void sessionExpiredShow() {
CheckSession.showLogoutDialog();
}
public void sessionExpiredShowDelayed() {
Timer timeoutTimer = new Timer() {
public void run() {
sessionExpiredShow();
}
};
int TIMEOUT = 3; // 3 second timeout
timeoutTimer.schedule(TIMEOUT * 1000); // timeout is in milliseconds
}
}

@ -25,8 +25,10 @@ public interface GCResources extends ClientBundle {
@Source("wizard-go_24.png")
ImageResource wizardGo24();
@Source("tool-button-close_20.png")
ImageResource toolButtonClose20();
@Source("search_16.png")
ImageResource search16();
}

@ -54,4 +54,16 @@
.wizard-tool-button-icon:hover {
height: 20px;
border: 1px solid #222;
}
}
.card-panel {
border: 1px solid #ccc;
background-color: white;
margin-top: 4px;
margin-bottom: 4px;
}
.card-panel-content {
margin: 6px;
}

@ -36,5 +36,11 @@ public interface WizardCSS extends CssResource {
@ClassName("wizard-tool-button-icon")
public String getWizardToolButtonIcon();
@ClassName("card-panel")
public String getCardPanel();
@ClassName("card-panel-content")
public String getCardPanelContent();
}

Binary file not shown.

After

Width:  |  Height:  |  Size: 569 B

@ -3,8 +3,9 @@ package org.gcube.portlets.widgets.githubconnector.client.rpc;
import java.util.ArrayList;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubCloneSession;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.session.UserInfo;
import com.google.gwt.user.client.rpc.RemoteService;
@ -20,6 +21,7 @@ public interface GitHubConnectorService extends RemoteService {
public ArrayList<GitHubRepository> getRepositories(String repositoryOwner, GitHubCredential gitHubCredential) throws ServiceException;
public void cloneRepository(GitHubCloneSession gitHubCloneSession) throws ServiceException;
}

@ -2,8 +2,9 @@ package org.gcube.portlets.widgets.githubconnector.client.rpc;
import java.util.ArrayList;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubCloneSession;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.session.UserInfo;
import com.google.gwt.core.client.GWT;
@ -26,4 +27,7 @@ public interface GitHubConnectorServiceAsync {
GitHubCredential gitHubCredential,
AsyncCallback<ArrayList<GitHubRepository>> callback);
void cloneRepository(GitHubCloneSession gitHubCloneSession,
AsyncCallback<Void> callback);
}

@ -1,6 +1,7 @@
package org.gcube.portlets.widgets.githubconnector.client.util;
import com.google.gwt.core.client.Callback;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.ui.Button;
@ -16,6 +17,9 @@ import com.google.gwt.user.client.ui.HTML;
*/
public class AlertDialog extends DialogBox implements ClickHandler {
private Callback<Void, Void> callback;
protected HTML msg;
protected double msgMinWidth=200;
protected double msgMinHeight=30;
public AlertDialog(String title, String text) {
@ -28,19 +32,23 @@ public class AlertDialog extends DialogBox implements ClickHandler {
private void init(String title, String text) {
setText(title);
Button closeButton = new Button("Close", this);
HTML msg = new HTML(text, true);
msg = new HTML(text, true);
msg.getElement().getStyle().setProperty("minWidth", msgMinWidth, Unit.PX);
msg.getElement().getStyle().setProperty("minHeight",msgMinHeight, Unit.PX);
DockPanel dock = new DockPanel();
dock.setSpacing(4);
dock.add(closeButton, DockPanel.SOUTH);
dock.add(msg, DockPanel.CENTER);
dock.setCellHorizontalAlignment(closeButton, DockPanel.ALIGN_CENTER);
dock.setWidth("100%");
setWidget(dock);
center();
}
@Override

@ -123,14 +123,8 @@ public class WizardWindow extends DialogBox {
}
});
nextButton = new Button("<div><span class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonText()
+ "'>" + msgs.buttonNextLabel() + "</span>" + "<img class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonIcon()
+ "'" + " src='"
+ GCResources.INSTANCE.wizardNext24().getSafeUri().asString()
+ "'/></div>");
nextButton = new Button();
setNextButtonToDefault();
nextButton.setEnabled(false);
nextButton.setTabIndex(1002);
nextButton.getElement().getStyle().setFloat(Float.RIGHT);
@ -196,72 +190,91 @@ public class WizardWindow extends DialogBox {
* Shows the next available card.
*/
public void nextCard() {
try {
int index = deckPanel.getVisibleWidget();
int newPos = 0;
if (index > -1) {
Widget activeItem = deckPanel.getWidget(index);
int index = deckPanel.getVisibleWidget();
Widget activeItem = deckPanel.getWidget(index);
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).dispose();
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).dispose();
int cardPos = cardStack.indexOf(activeItem);
int cardPos = cardStack.indexOf(activeItem);
deckPanel.remove(activeItem);
// NEXT ->
newPos = cardPos + 1;
}
nextButton.setEnabled(true);
backButton.setEnabled(true);
nextButtonAction = null;
previousButtonAction = null;
int newPos = cardPos + 1;
GWT.log("cardStack size:" + cardStack.size());
if (cardStack.size() > 0) {
nextButton.setEnabled(true);
backButton.setEnabled(true);
if (newPos == 0) {
// we are moving forward from the first card
backButton.setEnabled(false);
}
WizardCard card = cardStack.get(newPos);
deckPanel.add(card);
int indexNew = deckPanel.getWidgetIndex(card);
deckPanel.showWidget(indexNew);
card.setup();
nextButtonAction = null;
previousButtonAction = null;
GWT.log("cardStack size:" + cardStack.size());
WizardCard card = cardStack.get(newPos);
deckPanel.add(card);
int showIndex = deckPanel.getWidgetIndex(card);
deckPanel.showWidget(showIndex);
} else {
nextButton.setEnabled(false);
backButton.setEnabled(false);
}
if (card instanceof WizardCard)
((WizardCard) card).setup();
} catch (Throwable e) {
GWT.log("Error in nextCard():" + e.getLocalizedMessage());
e.printStackTrace();
}
}
/**
* Shows the previous available card.
*/
public void previousCard() {
int index = deckPanel.getVisibleWidget();
Widget activeItem = deckPanel.getWidget(index);
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).dispose();
int cardPos = cardStack.indexOf(activeItem);
try {
int index = deckPanel.getVisibleWidget();
int newPos = 0;
if (index > -1) {
Widget activeItem = deckPanel.getWidget(index);
// BACK <-
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).dispose();
deckPanel.remove(activeItem);
int cardPos = cardStack.indexOf(activeItem);
cardStack.remove(cardPos);
newPos = cardPos - 1;
}
nextButton.setEnabled(true);
backButton.setEnabled(true);
nextButtonAction = null;
previousButtonAction = null;
int newPos = cardPos - 1;
nextButton.setEnabled(true);
backButton.setEnabled(true);
if (newPos == 0) {
backButton.setEnabled(false);
}
if (newPos == 0) {
backButton.setEnabled(false);
}
nextButtonAction = null;
previousButtonAction = null;
GWT.log("cardStack size:" + cardStack.size());
if (cardStack.size() > 0) {
WizardCard card = cardStack.get(newPos);
deckPanel.add(card);
int indexNew = deckPanel.getWidgetIndex(card);
deckPanel.showWidget(indexNew);
card.setup();
WizardCard card = cardStack.get(newPos);
deckPanel.add(card);
int showIndex = deckPanel.getWidgetIndex(card);
deckPanel.showWidget(showIndex);
} else {
nextButton.setEnabled(false);
backButton.setEnabled(false);
}
if (card instanceof WizardCard)
((WizardCard) card).setup();
} catch (Throwable e) {
GWT.log("Error in previousCard():" + e.getLocalizedMessage());
e.printStackTrace();
}
}
/**
@ -294,11 +307,10 @@ public class WizardWindow extends DialogBox {
}
/**
* Sets the label of next button to "Finish" value and add a close command
* to it.
* Sets the label of next button to "Finish" value
*/
public void setNextButtonToFinish() {
nextButton = new Button("<div><span class='"
nextButton.setHTML("<div><span class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonText()
+ "'>" + msgs.buttonFinishLabel() + "</span>" + "<img class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonIcon()
@ -307,13 +319,22 @@ public class WizardWindow extends DialogBox {
+ "'/></div>");
// nextButton.setIcon(GCResources.INSTANCE.wizardGo());
// nextButton.setIconAlign(IconAlign.RIGHT);
nextButtonAction = new Command() {
/*
* nextButtonAction = new Command() {
*
* public void execute() { close(false); } };
*/
public void execute() {
close(false);
}
};
}
public void setNextButtonToDefault() {
nextButton.setHTML("<div><span class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonText()
+ "'>" + msgs.buttonNextLabel() + "</span>" + "<img class='"
+ GCResources.INSTANCE.wizardCSS().getWizardNextButtonIcon()
+ "'" + " src='"
+ GCResources.INSTANCE.wizardNext24().getSafeUri().asString()
+ "'/></div>");
}
/**
@ -345,13 +366,15 @@ public class WizardWindow extends DialogBox {
int index = deckPanel.getVisibleWidget();
GWT.log("Visible widget: " + index);
Widget activeItem;
if (index == -1) {
if (deckPanel.getWidgetCount() > 0) {
deckPanel.showWidget(0);
activeItem = deckPanel.getWidget(0);
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).setup();
if (cardStack.size() > 0) {
WizardCard firstCard = cardStack.get(0);
deckPanel.clear();
deckPanel.add(firstCard);
int activeIndex = deckPanel.getWidgetIndex(firstCard);
deckPanel.showWidget(activeIndex);
firstCard.setup();
backButton.setEnabled(false);
center();
} else {
@ -360,12 +383,10 @@ public class WizardWindow extends DialogBox {
}
} else {
deckPanel.showWidget(index);
activeItem = deckPanel.getWidget(index);
Widget activeItem = deckPanel.getWidget(index);
if (activeItem instanceof WizardCard)
((WizardCard) activeItem).setup();
}
}
@ -397,12 +418,6 @@ public class WizardWindow extends DialogBox {
*/
public void addCard(WizardCard card) {
card.setWizardWindow(this);
if (deckPanel.getVisibleWidget() > -1) {
int index = deckPanel.getVisibleWidget();
deckPanel.remove(index);
}
deckPanel.add(card);
cardStack.add(card);
}
@ -413,7 +428,6 @@ public class WizardWindow extends DialogBox {
* the card to add.
*/
public void removeCard(WizardCard card) {
deckPanel.remove(card);
cardStack.remove(card);
}

@ -10,8 +10,9 @@ import org.gcube.application.framework.core.session.ASLSession;
import org.gcube.portlets.widgets.githubconnector.client.rpc.GitHubConnectorService;
import org.gcube.portlets.widgets.githubconnector.server.git.GitConnectorService;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubCloneSession;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.session.UserInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -26,8 +27,9 @@ public class GitHubConnectorServiceImpl extends RemoteServiceServlet implements
GitHubConnectorService {
public static AccessLogger accountinglog = AccessLogger.getAccessLogger();
private static Logger logger = LoggerFactory.getLogger(GitHubConnectorServiceImpl.class);
private static Logger logger = LoggerFactory
.getLogger(GitHubConnectorServiceImpl.class);
@Override
public void init() throws ServletException {
super.init();
@ -65,13 +67,14 @@ public class GitHubConnectorServiceImpl extends RemoteServiceServlet implements
}
@Override
public ArrayList<GitHubRepository> getRepositories(String repositoryOwner, GitHubCredential gitHubCredential)
throws ServiceException {
public ArrayList<GitHubRepository> getRepositories(String repositoryOwner,
GitHubCredential gitHubCredential) throws ServiceException {
try {
HttpSession session = this.getThreadLocalRequest().getSession();
ASLSession aslSession = SessionUtil.getASLSession(session);
logger.debug("getRepository(): "+gitHubCredential);
GitConnectorService gitConnectorService=new GitConnectorService(aslSession.getUsername(), gitHubCredential);
logger.debug("getRepository(): " + gitHubCredential);
GitConnectorService gitConnectorService = new GitConnectorService(
aslSession.getUsername(), gitHubCredential);
return gitConnectorService.getRepositories(repositoryOwner);
} catch (ServiceException e) {
e.printStackTrace();
@ -83,6 +86,27 @@ public class GitHubConnectorServiceImpl extends RemoteServiceServlet implements
}
}
@Override
public void cloneRepository(GitHubCloneSession gitHubCloneSession)
throws ServiceException {
try {
HttpSession session = this.getThreadLocalRequest().getSession();
ASLSession aslSession = SessionUtil.getASLSession(session);
logger.debug("cloneRepository(): " + gitHubCloneSession);
GitConnectorService gitConnectorService = new GitConnectorService(
aslSession.getUsername(),
gitHubCloneSession.getGitHubCredential());
gitConnectorService.cloneRepository(gitHubCloneSession.getDestinationFolderId(),
gitHubCloneSession.getRepositoryOwner(), gitHubCloneSession.getRepositoryName());
return;
} catch (ServiceException e) {
e.printStackTrace();
throw e;
} catch (Throwable e) {
e.printStackTrace();
logger.error("Hello(): " + e.getLocalizedMessage(), e);
throw new ServiceException(e.getLocalizedMessage(), e);
}
}
}

@ -15,10 +15,10 @@ import org.eclipse.egit.github.core.service.DataService;
import org.eclipse.egit.github.core.service.RepositoryService;
import org.gcube.portlets.widgets.githubconnector.server.storage.StorageUtil;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredentialLogin;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredentialOAuth2;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredential;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialLogin;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialOAuth2;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ -6,8 +6,8 @@ import java.util.List;
import org.apache.log4j.Logger;
import org.eclipse.egit.github.core.Repository;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.GitHubUser;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubRepository;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.GitHubUser;
public class GitHubRepositoryBuilder {
private static Logger logger = Logger

@ -17,8 +17,10 @@ public class Constants {
public static final String DEFAULT_USER = "giancarlo.panichi";
public static final String DEFAULT_ROLE = "OrganizationMember";
public final static String DEFAULT_SCOPE = "/gcube/devsec/devVRE";
public static final String DEFAULT_SCOPE = "/gcube/devsec/devVRE";
public static final String DEFAULT_FOLDER_ID = "";
public static final String DEFAULT_REPOSITORY_OWNER = "jonan";
public static final String DEFAULT_REPOSITORY_NAME = "jonan.github.io";

@ -0,0 +1,92 @@
package org.gcube.portlets.widgets.githubconnector.shared.git;
import java.io.Serializable;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredential;
/**
*
* @author Giancarlo Panichi email: <a
* href="mailto:g.panichi@isti.cnr.it">g.panichi@isti.cnr.it</a>
*
*/
public class GitHubCloneSession implements Serializable {
private static final long serialVersionUID = 4995026750312087485L;
private String destinationFolderId;
private GitHubCredential gitHubCredential;
private String repositoryOwner;
private String repositoryName;
public GitHubCloneSession() {
super();
}
/**
*
* @param destinationFolderId
*/
public GitHubCloneSession(String destinationFolderId) {
super();
this.destinationFolderId = destinationFolderId;
}
/**
*
* @param destinationFolderId
* @param gitHubCredential
* @param repositoryOwner
* @param repositoryName
*/
public GitHubCloneSession(String destinationFolderId,
GitHubCredential gitHubCredential, String repositoryOwner,
String repositoryName) {
super();
this.destinationFolderId = destinationFolderId;
this.gitHubCredential = gitHubCredential;
this.repositoryOwner = repositoryOwner;
this.repositoryName = repositoryName;
}
public GitHubCredential getGitHubCredential() {
return gitHubCredential;
}
public void setGitHubCredential(GitHubCredential gitHubCredential) {
this.gitHubCredential = gitHubCredential;
}
public String getDestinationFolderId() {
return destinationFolderId;
}
public void setDestinationFolderId(String destinationFolderId) {
this.destinationFolderId = destinationFolderId;
}
public String getRepositoryOwner() {
return repositoryOwner;
}
public void setRepositoryOwner(String repositoryOwner) {
this.repositoryOwner = repositoryOwner;
}
public String getRepositoryName() {
return repositoryName;
}
public void setRepositoryName(String repositoryName) {
this.repositoryName = repositoryName;
}
@Override
public String toString() {
return "GitHubCloneSession [destinationFolderId=" + destinationFolderId
+ ", gitHubCredential=" + gitHubCredential
+ ", repositoryOwner=" + repositoryOwner + ", repositoryName="
+ repositoryName + "]";
}
}

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git;
package org.gcube.portlets.widgets.githubconnector.shared.git.data;
import java.io.Serializable;
import java.util.Date;

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git;
package org.gcube.portlets.widgets.githubconnector.shared.git.data;
import java.io.Serializable;

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git.credential;
package org.gcube.portlets.widgets.githubconnector.shared.git.data.credential;
import java.io.Serializable;

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git.credential;
package org.gcube.portlets.widgets.githubconnector.shared.git.data.credential;
/**
*

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git.credential;
package org.gcube.portlets.widgets.githubconnector.shared.git.data.credential;
/**
*

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git.credential;
package org.gcube.portlets.widgets.githubconnector.shared.git.data.credential;
/**
*

@ -1,4 +1,4 @@
package org.gcube.portlets.widgets.githubconnector.shared.git.credential;
package org.gcube.portlets.widgets.githubconnector.shared.git.data.credential;
/**

@ -17,7 +17,7 @@ import org.eclipse.egit.github.core.service.RepositoryService;
import org.gcube.portlets.widgets.githubconnector.server.git.GitConnectorService;
import org.gcube.portlets.widgets.githubconnector.shared.Constants;
import org.gcube.portlets.widgets.githubconnector.shared.exception.ServiceException;
import org.gcube.portlets.widgets.githubconnector.shared.git.credential.GitHubCredentialAnonymous;
import org.gcube.portlets.widgets.githubconnector.shared.git.data.credential.GitHubCredentialAnonymous;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -47,8 +47,8 @@ public class GitHubConnectorTest extends TestCase {
Constants.DEFAULT_USER, new GitHubCredentialAnonymous());
try {
gitConnectorService
.cloneRepository(Constants.DEFAULT_FOLDER_ID, "jonan",
"jonan.github.io");
.cloneRepository(Constants.DEFAULT_FOLDER_ID, Constants.DEFAULT_REPOSITORY_OWNER,
Constants.DEFAULT_REPOSITORY_NAME);
} catch (ServiceException e) {
assertFalse(true);
e.printStackTrace();

Loading…
Cancel
Save