CherryPickPage.java

package com.proalpha.pds.gitutils.cherrypick;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.mylyn.tasks.core.ITaskActivityManager;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.wb.swt.ResourceManager;
 
import com.proalpha.git.PaGitConfig;
import com.proalpha.git.model.server.GitServerRepository;
import com.proalpha.git.util.PaBranchName;
import com.proalpha.git.util.PaRepository;
import com.proalpha.git.util.bitbucket.BitbucketRestCallGetRepoList;
import com.proalpha.pds.gitutils.Activator;
import com.proalpha.pds.gitutils.PreferencesConstants;
 
class PrefixMatchFilter extends ViewerFilter {
 
    private String input = "";
 
    public void setInput(String s) {
        this.input = s.toLowerCase();
    }
 
    public String getInput() {
        return this.input;
    }
 
    @Override
    public boolean select(Viewer viewer, Object parentElement, Object element) {
        if (this.input == null || this.input.length() == 0) {
            return true;
        }
        String branchInList = (String) element;
 
        return (branchInList.toLowerCase().startsWith(this.input));
    }
}
 
public class CherryPickPage extends WizardPage {
 
    private Repository srcRepository;
    private List<GitServerRepository> currRepos;
    private Map<String, Set<String>> projectRepositoryMap;
 
    private Button btnUpdateTargetBranchPoint;
    private ComboViewer cvSrcProject;
    private ComboViewer cvSrcRepository;
    private ComboViewer cvSrcBranch;
    private Text txtSrcFeature;
    private Text txtTargetBranchPoint;
    private Text txtTargetBranch;
    private Text txtTargetFeature;
    private Button btnFetchCommits;
    private Button btnEditBranchname;
    private Button btnOnlyShowMaster;
    
    ScrolledComposite scrolledComposite;
    private Label infoLabel;
 
    private CherryPickSettings cherryPickSettings;
    private static final String PAGE_NAME = "pAGitCherryPickPage";
 
    public CherryPickPage(Repository repository) {
        super(CherryPickPage.class.getName());
 
        this.srcRepository = repository;
        setTitle("proALPHA CherryPick");
        setMessage("Select repository and branch which needs to get picked into your current repository", INFORMATION);
        URL url = FileLocator.find(Platform.getBundle(Activator.PLUGIN_ID), new Path("icons/pA-logox72.png"),
                Collections.emptyMap());
 
        setImageDescriptor(ImageDescriptor.createFromURL(url));
 
    }
 
    @Override
    public void createControl(Composite parent) {
        cherryPickSettings = ((CherryPickWizard) getWizard()).getSettings();
        currRepos = getServerRepositories();
        projectRepositoryMap = fillProjectRepositoryMap();
 
        Composite container = new Composite(parent, SWT.NULL);
        setControl(container);
        container.setLayout(new GridLayout(2, false));
 
        this.createSourceControls(container);
        this.createTargetControls(container);
 
        setControl(container);
        
        GridData gridData = new GridData(SWT.FILL, SWT.CENTER, false, false, 3, 1);
        Composite container_bottom = new Composite(container, SWT.None);
        container_bottom.setLayoutData(gridData);
        gridData.widthHint = 488;
        gridData.heightHint = 100;
        
        scrolledComposite = new ScrolledComposite(container_bottom, SWT.V_SCROLL | SWT.H_SCROLL);
        scrolledComposite.setExpandHorizontal(true);
        scrolledComposite.setExpandVertical(true);
        scrolledComposite.setBounds(0, 0, 408, 100);
 
        infoLabel = new Label(scrolledComposite, SWT.NONE);
        infoLabel.setBounds(0, 0, 408, 100);
        infoLabel.setText("");
        
        btnFetchCommits = new Button(container_bottom, SWT.NONE);
        btnFetchCommits.setBounds(443, 0, 120, 30);
        btnFetchCommits.setText("Fetch Commits");
        btnFetchCommits.setEnabled(false);
        
        addSrcWidgetListeners();
        addTargetWidgetListeners();
        addButtonWidgetListeners();
 
        checkRepoAndProposeBranches();
 
        // Propose a feature name based on the activated Mylyn task/issue
        ITaskActivityManager taskActivityManager = TasksUi.getTaskActivityManager();
        if (taskActivityManager != null && taskActivityManager.getActiveTask() != null
                && taskActivityManager.getActiveTask().getTaskKey() != null) {
            setTxtFeatureText(taskActivityManager.getActiveTask().getTaskKey());
            txtTargetFeature.setText(taskActivityManager.getActiveTask().getTaskKey());
        }
 
        setPageComplete(false);
    }
 
    private void createTargetControls(Composite container) {
        Group grpTarget = new Group(container, SWT.NONE);
        GridData gdGrpTarget = new GridData(SWT.FILL, SWT.CENTER, false, false, 3, 1);
        gdGrpTarget.widthHint = 450;
        gdGrpTarget.heightHint = 110;
        grpTarget.setLayoutData(gdGrpTarget);
        grpTarget.setText("Target");
 
        Label label1 = new Label(grpTarget, SWT.NONE);
        label1.setText("Repository");
        label1.setBounds(10, 22, 80, 15);
        
        Text txtTargetRepository;
        txtTargetRepository = new Text(grpTarget, SWT.NONE);
        txtTargetRepository.setBounds(96, 23, 347, 21);
        txtTargetRepository.setText(srcRepository.getDirectory().toString());
        txtTargetRepository.setEnabled(false);
 
        Label lblBranchPoint = new Label(grpTarget, SWT.NONE);
        lblBranchPoint.setText("Branch Point");
        lblBranchPoint.setBounds(10, 49, 80, 15);
 
        txtTargetBranchPoint = new Text(grpTarget, SWT.BORDER);
        txtTargetBranchPoint.setBounds(96, 46, 212, 21);
        try {
            // Try to determine the main branch of the repository
 
            List<String> branches = PaRepository.getMasterBranches(srcRepository);
 
            String mainBranch = null;
            if (branches != null && !branches.isEmpty())
                mainBranch = branches.get(0);
            else {
                branches = PaRepository.getCodeFreezeBranches(srcRepository);
                if (branches != null && !branches.isEmpty())
                    mainBranch = branches.get(0);
            }
 
            if (mainBranch == null)
                // Fallback: Load checked out branch, if no master or code-freeze branch is
                // available.
                mainBranch = srcRepository.getFullBranch();
 
            String remoteTrackingRef = PaRepository.getRemoteTrackingBranch(srcRepository, mainBranch);
 
            if (remoteTrackingRef == null || remoteTrackingRef.isEmpty())
                // Fallback to HEAD if no remote tracking branch could be determined
                // Hopefully never happens
                remoteTrackingRef = "HEAD";
 
            txtTargetBranchPoint.setText(remoteTrackingRef);
            cherryPickSettings.setTargetBranchPoint(remoteTrackingRef);
        } catch (IOException ex) {
            setMessage("Could not determine the branch name to be used as branching point!", IMessageProvider.ERROR);
        }
 
        btnUpdateTargetBranchPoint = new Button(grpTarget, SWT.CHECK);
        btnUpdateTargetBranchPoint.setBounds(314, 48, 129, 16);
        btnUpdateTargetBranchPoint.setText("update/fetch");
        btnUpdateTargetBranchPoint.setSelection(cherryPickSettings.isUpdateTargetBranchPoint());
 
        Label label2 = new Label(grpTarget, SWT.NONE);
        label2.setText("Branch");
        label2.setBounds(10, 76, 80, 15);
 
        txtTargetBranch = new Text(grpTarget, SWT.BORDER);
        txtTargetBranch.setBounds(96, 73, 212, 21);
        txtTargetBranch.setEnabled(false);
 
        btnEditBranchname = new Button(grpTarget, SWT.CHECK);
        btnEditBranchname.setBounds(314, 75, 129, 16);
        btnEditBranchname.setText("modify branch name");
 
        Label label3 = new Label(grpTarget, SWT.NONE);
        label3.setText("Feature");
        label3.setBounds(10, 103, 80, 15);
 
        txtTargetFeature = new Text(grpTarget, SWT.BORDER);
        txtTargetFeature.setBounds(96, 101, 162, 21);
    }
 
    private void createSourceControls(Composite container) {
        String gitDefaultRepo = Activator.getDefault().getPreferenceStore()
                .getString(PreferencesConstants.GIT_DEFAULT_REPO);
 
        String gitDefaultProject = "";
        String gitShortDefaultRepo = "";
        if (gitDefaultRepo.contains("/")) {
            String[] splitGitDefaultRepo = gitDefaultRepo.split("/");
            gitDefaultProject = splitGitDefaultRepo[0];
            gitShortDefaultRepo = splitGitDefaultRepo[1];
        }
 
        Group grpSource = new Group(container, SWT.NONE);
        GridData gdGrpSource = new GridData(SWT.FILL, SWT.TOP, true, false, 2, 1);
        gdGrpSource.heightHint = 111;
        gdGrpSource.widthHint = 450;
        grpSource.setLayoutData(gdGrpSource);
        grpSource.setText("Source");
 
        Label lblProject = new Label(grpSource, SWT.NONE);
        lblProject.setText("Project");
        lblProject.setBounds(10, 22, 80, 15);
 
        Label lblRepository = new Label(grpSource, SWT.NONE);
        lblRepository.setText("Repository");
        lblRepository.setBounds(10, 49, 80, 15);
 
        Label lblBranch = new Label(grpSource, SWT.NONE);
        lblBranch.setText("Branch");
        lblBranch.setBounds(10, 76, 80, 15);
 
        Label lblFeature = new Label(grpSource, SWT.NONE);
        lblFeature.setText("Feature");
        lblFeature.setBounds(10, 103, 80, 15);
 
        // Set the default value for the project Combo Box
        PrefixMatchFilter projectFilter = new PrefixMatchFilter();
        cvSrcProject = new ComboViewer(grpSource, SWT.BORDER);
        cvSrcProject.setContentProvider(ArrayContentProvider.getInstance());
        cvSrcProject.getCombo().setBounds(96, 19, 212, 21);
        cvSrcProject.addFilter(projectFilter);
 
        Set<String> projectsSet = projectRepositoryMap.keySet();
        String[] projects = new String[projectsSet.size()];
        projectsSet.toArray(projects);
        Arrays.sort(projects);
        cvSrcProject.setInput(projects);
        cvSrcProject.setSelection(new StructuredSelection(gitDefaultProject));
 
        // Set the default value for the repository Combo Box
        PrefixMatchFilter repositoryFilter = new PrefixMatchFilter();
        cvSrcRepository = new ComboViewer(grpSource, SWT.BORDER);
        cvSrcRepository.setContentProvider(ArrayContentProvider.getInstance());
        cvSrcRepository.getCombo().setBounds(96, 46, 212, 21);
        cvSrcRepository.addFilter(repositoryFilter);
 
        Set<String> repositorySet = projectRepositoryMap.get(gitDefaultProject);
        if (repositorySet == null) {
            repositorySet = new HashSet<String>();
        }
        String[] repositories = new String[repositorySet.size()];
        repositorySet.toArray(repositories);
        Arrays.sort(repositories);
        cvSrcRepository.setInput(repositories);
        cvSrcRepository.setSelection(new StructuredSelection(gitShortDefaultRepo));
 
        PrefixMatchFilter branchFilter = new PrefixMatchFilter();
        cvSrcBranch = new ComboViewer(grpSource, SWT.BORDER);
        cvSrcBranch.setContentProvider(ArrayContentProvider.getInstance());
        cvSrcBranch.getCombo().setBounds(96, 73, 212, 21);
        cvSrcBranch.addFilter(branchFilter);
        cvSrcBranch.addSelectionChangedListener(new ISelectionChangedListener() {
 
            @Override
            public void selectionChanged(SelectionChangedEvent event) {
                if (cvSrcBranch.getSelection() != event.getSelection()) {
                    setPageComplete(false);
                }
 
            }
        });
 
        txtSrcFeature = new Text(grpSource, SWT.BORDER);
        txtSrcFeature.setBounds(96, 100, 162, 21);
 
        Button btnRefreshRepos = new Button(grpSource, SWT.NONE);
        btnRefreshRepos.setToolTipText("Reload repositories from server");
        btnRefreshRepos.setImage(ResourceManager.getPluginImage("com.proalpha.pds.gitutils", "icons/refresh.gif"));
        btnRefreshRepos.setBounds(314, 18, 28, 23);
 
        IDialogSettings settings = getDialogSettings();
        btnOnlyShowMaster = new Button(grpSource, SWT.CHECK);
        btnOnlyShowMaster.setBounds(314, 75, 129, 16);
        btnOnlyShowMaster.setText("only show master");
        btnOnlyShowMaster.setSelection(settings.getBoolean("ONLY_SHOW_MASTER"));
 
    }
 
    private void addSrcWidgetListeners() {
 
        cvSrcProject.getCombo().addModifyListener(modifyEvent -> proposeRepositories());
        cvSrcRepository.getCombo().addModifyListener(modifyEvent -> checkRepoAndProposeBranches());
        cvSrcRepository.getCombo().addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Choose your source repository");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                if (cvSrcBranch.getCombo().getText().length() != 0)
                    checkBranch();
            }
        });
 
        cvSrcBranch.getCombo().addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Choose your source branch");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                if (cvSrcBranch.getCombo().getText().length() != 0 && checkBranch()) {
                    String featureByBranch = getFeatureText(cvSrcBranch.getCombo().getText());
                    if (featureByBranch != null)
                        setTxtFeatureText(featureByBranch);
                }
            }
        });
 
        txtSrcFeature.addModifyListener(modifyEvent -> {
            if (cvSrcBranch.getCombo().getText().length() != 0) {
                checkBranch();
                txtTargetFeature.setText(txtSrcFeature.getText());
            }
        });
        txtSrcFeature.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Type your feature to pick");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                if (cvSrcBranch.getCombo().getText().length() != 0 && txtSrcFeature.getText().length() != 0) {
                    btnFetchCommits.setEnabled(true);
                }
                String feature = txtSrcFeature.getText();
                check_caused_issues(feature);
            }
        });
 
        KeyListener projectKeyListener = createKeyListener(cvSrcProject);
        cvSrcProject.getCombo().addKeyListener(projectKeyListener);
 
        KeyListener repositoryKeyListener = createKeyListener(cvSrcRepository);
        cvSrcRepository.getCombo().addKeyListener(repositoryKeyListener);
 
        KeyListener branchKeyListener = createKeyListener(cvSrcBranch);
        cvSrcBranch.getCombo().addKeyListener(branchKeyListener);
 
        cvSrcBranch.getCombo().addModifyListener(modifyListener -> {
            if (cvSrcBranch.getCombo().getText().length() != 0 && checkBranch()) {
                String featureByBranch = getFeatureText(cvSrcBranch.getCombo().getText());
                if (featureByBranch != null)
                    setTxtFeatureText(featureByBranch);
            }
        });
    }
    
    private void check_caused_issues(String issue) {
        List<String> command = new LinkedList<String>();
        command.add("python");
        command.add("-m");
        command.add("pa_common.pds_functions.jira_issue_links");
        command.add("-i");
        command.add(issue);
        command.add("-l");
        command.add("INFO");
        
        infoLabel.setText("");
        run_command(command);
    }
    
    private boolean run_command(List<String> command) {
        boolean result = false;
        ProcessBuilder builder = new ProcessBuilder();
        builder.command(command);
        Process p;
        try {
            p = builder.start();
            
            InputStream inputStream = p.getErrorStream();
            BufferedReader bufRead = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = bufRead.readLine()) != null) {
                String text = infoLabel.getText();
                infoLabel.setText(text + "\n" + line);
                this.getShell().getDisplay().update();
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
 
    private void setTxtFeatureText(String text) {
        txtSrcFeature.setText(text);
        txtSrcFeature.setFocus();
        getShell().setFocus();
    }
    
    private KeyListener createKeyListener(ComboViewer viewer) {
        return new KeyListener() {
 
            @Override
            public void keyPressed(final KeyEvent e) {
                // Must be implemented in KeyListener
            }
 
            @Override
            public void keyReleased(final KeyEvent e) {
                String currentInput = viewer.getCombo().getText();
                String inputFilter = ((PrefixMatchFilter) viewer.getFilters()[0]).getInput();
 
                // Only refresh the filter if the old search string was shortened or
                // a printable character was inserted
                if (currentInput.length() < inputFilter.length() || Character.isDigit(e.character)
                        || Character.isAlphabetic(e.character)) {
                    if (e.keyCode == SWT.ESC) {
                        ((PrefixMatchFilter) viewer.getFilters()[0]).setInput("");
                        currentInput = "";
                    } else {
                        ((PrefixMatchFilter) viewer.getFilters()[0]).setInput(currentInput);
                    }
 
                    // Run the filter by refreshing and "drop-down" the list
                    viewer.refresh(true);
                    viewer.getCombo().setListVisible(e.keyCode != SWT.ESC);
 
                    // SetListVisible selects the first matching item, so we have to set
                    // the old string again and even position the cursor.
                    viewer.getCombo().setText(currentInput);
                    viewer.getCombo().setSelection(new Point(currentInput.length(), currentInput.length()));
 
                }
            }
        };
    }
 
    private void addTargetWidgetListeners() {
 
        txtTargetBranchPoint.addModifyListener(modifyEvent -> {
            if (txtTargetBranchPoint.getText().length() != 0) {
                cherryPickSettings.setTargetBranchPoint(txtTargetBranchPoint.getText());
            }
        });
 
        txtTargetBranchPoint.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Type your new branch point");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                // Must be implemented in FocusListener
            }
        });
 
        txtTargetBranch.addModifyListener(modifyEvent -> {
            if (txtTargetBranch.getText().length() != 0) {
                cherryPickSettings.setTargetBranch(txtTargetBranch.getText());
            }
        });
 
        txtTargetBranch.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Type your new branchname");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                if (txtTargetBranch.getText().length() != 0) {
                    String featureByBranch = getFeatureText(txtTargetBranch.getText());
                    if (featureByBranch != null)
                        txtTargetFeature.setText(featureByBranch);
                }
            }
        });
 
        txtTargetFeature.addModifyListener(modifyEvent -> {
            if (txtTargetFeature.getText().length() != 0) {
                cherryPickSettings.setTargetIssue(txtTargetFeature.getText());
            }
        });
        txtTargetFeature.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Choose a target feature which is used for first line of commit message");
            }
 
            @Override
            public void focusLost(FocusEvent e) {
                if (txtTargetFeature.getText().length() == 0) {
                    String featureByBranch = getFeatureText(txtTargetBranch.getText());
                    if (featureByBranch != null)
                        txtTargetFeature.setText(featureByBranch);
                }
 
                cherryPickSettings.setTargetIssue(txtTargetFeature.getText());
            }
        });
 
        btnUpdateTargetBranchPoint.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                cherryPickSettings.setUpdateTargetBranchPoint(btnUpdateTargetBranchPoint.getSelection());
            }
        });
    }
 
    private void addButtonWidgetListeners() {
 
        btnEditBranchname.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                txtTargetBranch.setEnabled(btnEditBranchname.getSelection());
                if (!btnEditBranchname.getSelection())
                    checkBranch();
            }
        });
 
        btnFetchCommits.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                fetchCommits();
            }
        });
 
        btnOnlyShowMaster.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                IDialogSettings settings = getDialogSettings();
                settings.put("ONLY_SHOW_MASTER", btnOnlyShowMaster.getSelection());
                checkRepoAndProposeBranches();
            }
        });
    }
 
    protected void fetchCommits() {
 
        cherryPickSettings.setSourceIssue(txtSrcFeature.getText());
        cherryPickSettings.setSourceBranch(cvSrcBranch.getCombo().getText());
        cherryPickSettings.setTargetIssue(txtTargetFeature.getText());
 
        String projectname = cvSrcProject.getCombo().getText();
        String repoName = cvSrcRepository.getCombo().getText();
 
        for (GitServerRepository actRepo : currRepos) {
            if (actRepo.getProject().equals(projectname) && actRepo.getName().equals(repoName)) {
                cherryPickSettings.setSourceRepoString(projectname, repoName);
                break;
            }
        }
 
        Boolean commitsfound = ((CherryPickWizard) getWizard()).gatherCommits();
        if (!commitsfound)
            setMessage("No commits found!", IMessageProvider.WARNING);
        else
            setMessage("Commits found! Push 'Next' to view or 'Finish' to pick them", INFORMATION);
        setPageComplete(commitsfound);
    }
 
    private List<GitServerRepository> getServerRepositories() {
 
        ArrayList<GitServerRepository> serverRepositories;
 
        BitbucketRestCallGetRepoList restcall = new BitbucketRestCallGetRepoList();
        restcall.setSubUrl("repos");
        restcall.execute();
        serverRepositories = restcall.getRestResponse();
 
        return serverRepositories;
    }
 
    private String getFeatureText(String branchText) {
 
        Pattern p = Pattern.compile("(.*\\.)?(" + PaGitConfig.getStringFromConfig("issue_key_format") + ")$");
        Matcher m = p.matcher(branchText);
 
        if (m.find())
            return m.group(2);
 
        return null;
 
    }
 
    private boolean checkBranch() {
 
        boolean foundIt = false;
        String srcBranchName = cvSrcBranch.getCombo().getText();
        setMessage(null, IMessageProvider.INFORMATION);
        setErrorMessage(null);
 
        if (srcBranchName.length() == 0) {
            setPageComplete(false);
            return false;
        }
 
        String projectname = cvSrcProject.getCombo().getText();
        String repoName = cvSrcRepository.getCombo().getText();
 
        for (GitServerRepository repository : currRepos) {
            if (repository.getProject().equals(projectname) && repository.getName().equals(repoName)) {
                for (String actBranch : repository.getBranches()) {
                    if (actBranch.equals(srcBranchName)) {
                        foundIt = true;
                    }
                }
            }
            if (foundIt)
                break;
        }
 
        if (!foundIt) {
            setMessage("Branch not found!", IMessageProvider.WARNING);
            setPageComplete(false);
            btnFetchCommits.setEnabled(false);
            return false;
        }
 
        cherryPickSettings.setSourceBranch(srcBranchName);
 
        proposeTargetBranchName(srcBranchName);
 
        btnFetchCommits.setEnabled(true);
        return true;
 
    }
 
    private void proposeTargetBranchName(String srcBranchName) {
        String targetBranch = srcBranchName;
        try {
            // Try to guess the version of the target branch
            // In case, this is a pick with a non-proALPHA conform repo, the
            // version can not be extracted from the branch name
            String versionPrefix = PaBranchName.getVersion(this.srcRepository.getBranch());
            if (versionPrefix != null)
                versionPrefix = versionPrefix + ".";
            else
                versionPrefix = "";
 
            if (this.txtSrcFeature.getText() != null && !this.txtSrcFeature.getText().isEmpty()) {
                targetBranch = versionPrefix + this.txtSrcFeature.getText();
            } else {
                // we can only pre-insert the version. the feature is not known
                targetBranch = versionPrefix;
            }
        } catch (IOException e) {
            // Just ignore... if the exception is thrown, we can't identify a valid branch
            // name
        }
 
        txtTargetBranch.setText(targetBranch);
        cherryPickSettings.setTargetBranch(targetBranch);
    }
 
    protected void checkRepoAndProposeBranches() {
        List<String> allBranches;
        boolean foundIt = false;
        setMessage(null, IMessageProvider.INFORMATION);
        setErrorMessage(null);
 
        if (cvSrcRepository.getCombo().getText().length() == 0) {
            setPageComplete(false);
            return;
        }
 
        String projectname = cvSrcProject.getCombo().getText();
        String repoName = cvSrcRepository.getCombo().getText();
 
        for (GitServerRepository repository : currRepos) {
            if (repository.getProject().equals(projectname) && repository.getName().equals(repoName)) {
                allBranches = repository.getBranches();
                Collections.sort(allBranches);
                String[] branches = allBranches.stream().toArray(String[]::new);
                if (btnOnlyShowMaster.getSelection()) {
                    branches = filterMasterBranches(branches);
                }
                cvSrcBranch.setInput(branches);
                foundIt = true;
                break;
            }
        }
 
        if (!foundIt) {
            setMessage("Repository not found!", IMessageProvider.WARNING);
            setPageComplete(false);
            btnFetchCommits.setEnabled(false);
            cvSrcBranch.setInput(new String[0]);
            return;
        }
 
        cherryPickSettings.setSourceRepoString(projectname, repoName);
 
    }
 
    protected void proposeRepositories() {
 
        String projectname = cvSrcProject.getCombo().getText();
        if (!projectRepositoryMap.containsKey(projectname)) {
            setMessage("Project not found!", IMessageProvider.WARNING);
            setPageComplete(false);
            cvSrcRepository.setInput(new String[0]);
            return;
        }
 
        Set<String> repoSet = projectRepositoryMap.get(projectname);
        String[] repos = new String[repoSet.size()];
        repoSet.toArray(repos);
        Arrays.sort(repos);
        cvSrcRepository.setInput(repos);
 
    }
 
    private Map<String, Set<String>> fillProjectRepositoryMap() {
 
        projectRepositoryMap = new HashMap<String, Set<String>>();
        for (GitServerRepository repository : currRepos) {
 
            Set<String> repositoriesForProject = projectRepositoryMap.get(repository.getProject());
 
            if (repositoriesForProject != null) {
                repositoriesForProject.add(repository.getName());
            } else {
                String projectName = repository.getProject();
                String repositoryName = repository.getName();
                Set<String> repositories = new HashSet<String>();
                repositories.add(repositoryName);
                projectRepositoryMap.put(projectName, repositories);
            }
        }
        return projectRepositoryMap;
    }
 
    private String[] filterMasterBranches(String[] branches) {
 
        List<String> masterBranches = new ArrayList<String>();
        for (String branch : branches) {
            if (branch.contains("master")) {
                masterBranches.add(branch);
            }
        }
 
        String[] masterArray = new String[masterBranches.size()];
        masterBranches.toArray(masterArray);
 
        return masterArray;
    }
 
    @Override
    protected IDialogSettings getDialogSettings() {
 
        IDialogSettings dialogSettings = Activator.getDefault().getDialogSettings();
        IDialogSettings section = dialogSettings.getSection(PAGE_NAME);
        if (section == null)
            section = dialogSettings.addNewSection(PAGE_NAME);
        return section;
 
    }
 
}