CherryPickResultDialog.java

package com.proalpha.pds.gitutils.cherrypick;
 
import java.io.IOException;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.egit.core.internal.util.ProjectUtil;
import org.eclipse.egit.ui.internal.push.PushBranchWizard;
import org.eclipse.egit.ui.internal.push.PushWizardDialog;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider;
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jgit.api.CherryPickResult;
import org.eclipse.jgit.api.CherryPickResult.CherryPickStatus;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.PlatformUI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
import com.proalpha.git.model.PaCherryPickResult;
import com.proalpha.pds.gitutils.external.DbAndBinaryOperation;
import com.proalpha.pds.gitutils.mylyn.CheckoutAction;
import com.proalpha.pds.gitutils.mylyn.ReconcileActionSettings;
import com.proalpha.pds.paconnector.Activator;
 
public class CherryPickResultDialog extends Dialog {
 
    private final Logger logger = LoggerFactory.getLogger(CherryPickResultDialog.class);
 
    private final PaCherryPickResult result;
    private final List<RevCommit> successfulPicks;
    private final List<RevCommit> openPicks;
    private Button btnPush;
    private Label lblHint;
    private CheckoutAction currentAction = CheckoutAction.NONE;
    private IProgressMonitor monitor;
 
    @Override
    protected Control createDialogArea(Composite parent) {
 
        Composite main = new Composite(parent, SWT.NONE);
        GridLayoutFactory.swtDefaults().applyTo(main);
        GridDataFactory.fillDefaults().indent(0, 0).grab(true, true).applyTo(main);
        main.setLayout(new GridLayout(1, false));
 
        Composite composite = new Composite(main, SWT.NONE);
        composite.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
        composite.setLayout(new GridLayout(2, false));
        Label lblNewLabel = new Label(composite, SWT.NONE);
        lblNewLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
        lblNewLabel.setText("Result Status:");
 
        Text text = new Text(composite, SWT.READ_ONLY);
        text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
        text.setText(result.getStatus().toString());
        text.setFont(JFaceResources.getFont("Courier New"));
 
        Group grpPerformedcommits = new Group(main, SWT.NONE);
        grpPerformedcommits.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
        grpPerformedcommits.setText("Performed Commits");
 
        TreeViewer succViewer = new TreeViewer(grpPerformedcommits);
        Tree succTree = succViewer.getTree();
        succTree.setBounds(0, 22, 460, 130);
        succViewer.setAutoExpandLevel(2);
        fillTreeView(succViewer, this.successfulPicks);
 
        Group grpOpenCommits = new Group(main, SWT.NONE);
        grpOpenCommits.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
        grpOpenCommits.setText("Open Commits");
 
        TreeViewer openViewer = new TreeViewer(grpOpenCommits);
        Tree openTree = openViewer.getTree();
        openTree.setBounds(10, 22, 460, 90);
        openViewer.setAutoExpandLevel(2);
        fillTreeView(openViewer, this.openPicks);
 
        btnPush = new Button(main, SWT.CHECK);
        btnPush.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
        btnPush.addSelectionListener(new SelectionListener() {
 
            @Override
            public void widgetSelected(SelectionEvent event) {
                if (!btnPush.getSelection()) {
                    lblHint.setText("Hint: Dont't forget to push your picked branch to the remote Repository!");
                } else {
                    lblHint.setText("");
                }
                main.layout(true);
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent event) {
                widgetSelected(event);
            }
        });
        btnPush.setText("Push automatically to server");
        btnPush.setSelection(true);
 
        /* Reconcile settings */
 
        Group grpCheckoutSettings = new Group(main, SWT.NONE);
        grpCheckoutSettings.setText("Reconcile settings");
        grpCheckoutSettings.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
        grpCheckoutSettings.setLayout(new GridLayout(1, false));
        Combo cmbCheckoutAction = new Combo(grpCheckoutSettings, SWT.CHECK);
        cmbCheckoutAction.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
        cmbCheckoutAction.addSelectionListener(new SelectionListener() {
            public void widgetSelected(SelectionEvent selectedItem) {
                currentAction = null;
                if (selectedItem != null) {
                    currentAction = CheckoutAction.getAction(((Combo) selectedItem.getSource()).getText());
                }
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                // We don't need this
            }
        });
        cmbCheckoutAction.setBounds(76, 22, 300, 16);
        String[] checkoutActions = CheckoutAction.getActions();
        cmbCheckoutAction.setItems(checkoutActions);
 
        int selectionIndex = determineSelectionIndex(checkoutActions, CheckoutAction.LOAD_XML.getValue());
        cmbCheckoutAction.select(selectionIndex);
 
        lblHint = new Label(main, SWT.NONE);
        lblHint.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
 
        if (result.getStatus() == CherryPickResult.CherryPickStatus.FAILED) {
            lblHint.setText(
                    "Something wicked happended!\nThe cherrypick terribly failed :-/\nGo to history view to reset your branch.");
            text.setForeground(parent.getDisplay().getSystemColor(SWT.COLOR_RED));
        }
        if (result.getStatus() == CherryPickResult.CherryPickStatus.OK) {
            text.setForeground(parent.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN));
        }
        if (result.getStatus() == CherryPickResult.CherryPickStatus.CONFLICTING) {
            lblHint.setText(
                    "There is a conflict in your pick.\nPlease resolve the conflict in Git Staging view,\ncommit your change and resume the cherrypick!");
            text.setForeground(parent.getDisplay().getSystemColor(SWT.COLOR_BLUE));
        }
 
        return main;
    }
 
    private int determineSelectionIndex(String[] checkoutActions, String searchValue) {
        int selectionIndex = 0;
        for (String action : checkoutActions) {
 
            if (action.equals(searchValue)) {
                break;
            }
            selectionIndex++;
        }
        return selectionIndex;
    }
 
    protected CherryPickResultDialog(Shell parentShell, IProgressMonitor monitor, PaCherryPickResult cpResult) {
        super(parentShell);
        this.monitor = monitor;
        this.result = cpResult;
        this.successfulPicks = cpResult.getSuccessfulPicks();
        this.openPicks = cpResult.getOpenPicks();
    }
 
    @Override
    protected void okPressed() {
        CherryPickStatus status = this.result.getStatus();
 
        if (status == CherryPickStatus.OK && btnPush.getSelection()) {
            try {
                final Repository repository = PaGit.getInstance().getGit().getRepository();
                PushBranchWizard wizard = null;
                Ref ref = null;
                String fullBranch = repository.getFullBranch();
 
                if (fullBranch != null && fullBranch.startsWith(Constants.R_HEADS))
                    ref = repository.exactRef(fullBranch);
 
                if (ref != null) {
                    wizard = new PushBranchWizard(repository, ref);
                } else {
                    ObjectId id = repository.resolve(repository.getFullBranch());
                    wizard = new PushBranchWizard(repository, id);
                }
 
                new PushWizardDialog(PlatformUI.getWorkbench().getDisplay().getActiveShell(), wizard).open();
 
                // only start an operation if the checkout-action is not "NONE"
                if (currentAction != CheckoutAction.NONE) {
                    performReconcileJob(repository, currentAction, monitor);
                }
 
            } catch (IOException ex) {
                PlatformUI.getWorkbench().getDisplay().asyncExec(
                        () -> MessageDialog.openError(PlatformUI.getWorkbench().getDisplay().getActiveShell(),
                                ex.getMessage(), ex.getLocalizedMessage()));
            }
        }
        super.okPressed();
    }
 
    private void performReconcileJob(Repository repository, CheckoutAction checkoutAction, IProgressMonitor monitor) {
 
        IProject[] projects = ProjectUtil.getProjects(repository);
        ArrayList<IProject> affectedProjects = new ArrayList<>(Arrays.asList(projects));
        SubMonitor subMonitorArtifacts = SubMonitor.convert(monitor, "database reconcile and artifact update", 10);
 
        if (checkoutAction.equals(CheckoutAction.FULL_RECONCILE))
            Activator.getDefault().getProjectManager().closeProjects(affectedProjects, subMonitorArtifacts);
 
        executeDbBinaryOperation(repository, checkoutAction, subMonitorArtifacts);
 
        if (checkoutAction.equals(CheckoutAction.FULL_RECONCILE))
            Activator.getDefault().getProjectManager().openProjects(affectedProjects, subMonitorArtifacts);
    }
 
    public void executeDbBinaryOperation(Repository repository, CheckoutAction checkoutAction,
            SubMonitor subMonitorArtifacts) {
        DbAndBinaryOperation updateDbBinaryOp = new DbAndBinaryOperation(repository,
                new ReconcileActionSettings(checkoutAction));
        updateDbBinaryOp.setProgressMonitor(subMonitorArtifacts);
        updateDbBinaryOp.execute();
    }
 
    @Override
    protected void createButtonsForButtonBar(Composite parent) {
        createButton(parent, IDialogConstants.OK_ID, IDialogConstants.CLOSE_LABEL, true);
    }
 
    @Override
    protected void configureShell(Shell newShell) {
        super.configureShell(newShell);
        newShell.setText("CherryPick Result: " + result.getStatus());
    }
 
    private void fillTreeView(TreeViewer treeViewer, List<RevCommit> commits) {
 
        TreeViewerColumn treeViewerColumn_2 = new TreeViewerColumn(treeViewer, SWT.NONE);
        TreeColumn trclmnNewColumn_2 = treeViewerColumn_2.getColumn();
        trclmnNewColumn_2.setWidth(80);
        trclmnNewColumn_2.setText("CommitID");
        treeViewerColumn_2.setLabelProvider(new DelegatingStyledCellLabelProvider(new NameLabelProvider()));
 
        TreeViewerColumn treeViewerColumn_1 = new TreeViewerColumn(treeViewer, SWT.NONE);
        TreeColumn trclmnNewColumn_1 = treeViewerColumn_1.getColumn();
        trclmnNewColumn_1.setWidth(200);
        trclmnNewColumn_1.setText("Message");
        trclmnNewColumn_1.setAlignment(SWT.LEFT);
        treeViewerColumn_1.setLabelProvider(new DelegatingStyledCellLabelProvider(new MessageLabelProvider()));
 
        TreeViewerColumn treeViewerColumn = new TreeViewerColumn(treeViewer, SWT.NONE);
        TreeColumn trclmnNewColumn = treeViewerColumn.getColumn();
        trclmnNewColumn.setWidth(100);
        trclmnNewColumn.setText("Author");
        trclmnNewColumn.setAlignment(SWT.LEFT);
        treeViewerColumn.setLabelProvider(new DelegatingStyledCellLabelProvider(new AuthorLabelProvider()));
 
        TreeViewerColumn dateColumn = new TreeViewerColumn(treeViewer, SWT.NONE);
        TreeColumn trclmnDateColumn = dateColumn.getColumn();
        trclmnDateColumn.setWidth(70);
        trclmnDateColumn.setText("Date");
        trclmnDateColumn.setAlignment(SWT.LEFT);
        dateColumn.setLabelProvider(new DelegatingStyledCellLabelProvider(new DateLabelProvider()));
 
        treeViewer.setContentProvider(new CommitProvider());
        treeViewer.setInput(commits);
 
        treeViewer.getTree().setHeaderVisible(true);
        treeViewer.getTree().setLinesVisible(true);
    }
 
    public class CommitProvider implements ITreeContentProvider {
 
        public void inputChanged(Viewer v, Object oldInput, Object newInput) {
        }
 
        @Override
        public void dispose() {
        }
 
        @Override
        public Object[] getElements(Object inputElement) {
            if (inputElement instanceof List) {
                return ((List<?>) inputElement).toArray();
            }
            return new Object[0];
        }
 
        @Override
        public Object[] getChildren(Object parentElement) {
            return null;
        }
 
        @Override
        public Object getParent(Object element) {
            return null;
        }
 
        @Override
        public boolean hasChildren(Object element) {
            return false;
        }
 
    }
 
    class NameLabelProvider extends LabelProvider implements IStyledLabelProvider {
 
        @Override
        public StyledString getStyledText(Object element) {
            if (element instanceof RevCommit) {
                RevCommit commit = (RevCommit) element;
                return new StyledString(commit.getName().substring(0, 8));
            }
            return null;
        }
 
    }
 
    class MessageLabelProvider extends LabelProvider implements IStyledLabelProvider {
 
        @Override
        public StyledString getStyledText(Object element) {
            if (element instanceof RevCommit) {
                RevCommit commit = (RevCommit) element;
                return new StyledString(commit.getFullMessage().replace("\n", " "));
            }
            return null;
        }
 
    }
 
    class AuthorLabelProvider extends LabelProvider implements IStyledLabelProvider {
 
        @Override
        public StyledString getStyledText(Object element) {
            if (element instanceof RevCommit) {
                RevCommit commit = (RevCommit) element;
                return new StyledString(commit.getAuthorIdent().getName());
            }
            return null;
        }
 
    }
 
    class DateLabelProvider extends LabelProvider implements IStyledLabelProvider {
 
        private DateFormat dateLabelFormat;
 
        public DateLabelProvider() {
            dateLabelFormat = DateFormat.getDateInstance();
        }
 
        @Override
        public StyledString getStyledText(Object element) {
            if (element instanceof RevCommit) {
                RevCommit commit = (RevCommit) element;
                return new StyledString(dateLabelFormat.format(commit.getCommitterIdent().getWhen()));
            }
            return null;
        }
 
    }
}