MultiCherryPickPage.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.nio.charset.StandardCharsets;
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.StructuredSelection;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.jgit.lib.Repository;
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.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
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.PaRepository;
import com.proalpha.git.util.bitbucket.BitbucketRestCallGetRepoList;
import com.proalpha.pds.gitutils.Activator;
import com.proalpha.pds.gitutils.PreferencesConstants;
 
public class MultiCherryPickPage extends WizardPage{
 
    private Repository targetRepository;
    private List<GitServerRepository> currRepos;
    private Map<String, Set<String>> projectRepositoryMap;
    
    private ComboViewer cvSrcProject;
    private ComboViewer cvSrcRepository;
    private ComboViewer cvSrcBranch;
    private Text txtSrcFeature;
    private Text txtTargetBranchPoint;
    private Button btnOnlyShowMaster;
    private Button btnRunTest;
    private Button btnRunTarget;
    
    private org.eclipse.swt.widgets.List infoList;
    private Label infoLabel;
    private Display display;
    
    ScrolledComposite scrolledComposite;
    
    private CherryPickSettings cherryPickSettings;
    private Map<String, List<String>> causedIssues;
    private static final String PAGE_NAME = "pAGitMultiCherryPickPage";
    
    public MultiCherryPickPage(Repository repository) {
        
        super(MultiCherryPickPage.class.getName());
        this.targetRepository = repository;
        setTitle("proALPHA MultiCherryPick");
        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));
        
        causedIssues = new HashMap<String, List<String>>();
    
    }
    
    private void disableAll() {
        cvSrcBranch.getCombo().setEnabled(false);
        cvSrcProject.getCombo().setEnabled(false);
        cvSrcRepository.getCombo().setEnabled(false);
        btnRunTest.setEnabled(false);
        txtSrcFeature.setEnabled(false);
        txtTargetBranchPoint.setEnabled(false);
        btnOnlyShowMaster.setEnabled(false);
 
        display.update();
    }
    
    private void enableAll() {
        cvSrcBranch.getCombo().setEnabled(true);
        cvSrcProject.getCombo().setEnabled(true);
        cvSrcRepository.getCombo().setEnabled(true);
        btnRunTest.setEnabled(true);
        txtSrcFeature.setEnabled(true);
        txtTargetBranchPoint.setEnabled(true);
        btnOnlyShowMaster.setEnabled(true);
 
        display.update();
    }
    
    
    
    @Override
    public void createControl(Composite parent) {
 
        
        cherryPickSettings = ((MultiCherryPickWizard) getWizard()).getSettings();
        currRepos = getServerRepositories();
        projectRepositoryMap = fillProjectRepositoryMap();
    
        Composite container = new Composite(parent, SWT.NULL);
        setControl(container);
        display = this.getShell().getDisplay();
        
        
        //setControl(container);
        container.setLayout(new GridLayout(1, 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);
        
        infoList = new org.eclipse.swt.widgets.List(scrolledComposite, SWT.NONE);
        infoList.setBounds(0, 0, 408, 100);
        infoList.add("");
        
        
        infoLabel = new Label(scrolledComposite, SWT.NONE);
        infoLabel.setBounds(0, 0, 408, 100);
        infoLabel.setText("");
        infoLabel.moveAbove(infoList);
        
 
        scrolledComposite.setContent(infoLabel);
        
        
        btnRunTest = new Button(container_bottom, SWT.NONE);
        btnRunTest.setBounds(408, 0, 80, 30);
        btnRunTest.setText("Test Merge");
        
        btnRunTarget = new Button(container_bottom, SWT.NONE);
        btnRunTarget.setBounds(408, 45, 80, 30);
        btnRunTarget.setText("Target Merge");
        btnRunTarget.setEnabled(false);
        
        addSrcWidgetListeners();
        addTargetWidgetListeners();
        addButtonWidgetListeners();
    
        checkRepoAndProposeBranches();
    }
    
    private void createTargetControls(Composite container) {
        Group grpTarget = new Group(container, SWT.NONE);
        GridData gdGrpTarget = new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1);
        gdGrpTarget.widthHint = 450;
        gdGrpTarget.heightHint = 60;
        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(targetRepository.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(targetRepository);
    
            String mainBranch = null;
            if (branches != null && !branches.isEmpty())
                mainBranch = branches.get(0);
            else {
                branches = PaRepository.getCodeFreezeBranches(targetRepository);
                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 = targetRepository.getFullBranch();
    
            String remoteTrackingRef = PaRepository.getRemoteTrackingBranch(targetRepository, 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);
        }
    }
    
    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);
    
        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();
                cherryPickSettings.setSourceIssue(txtSrcFeature.getText());
                btnRunTarget.setEnabled(false);
            }
        });
        txtSrcFeature.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                setMessage("Type your feature to pick");
            }
    
            @Override
            public void focusLost(FocusEvent e) {
                String features_string = txtSrcFeature.getText();
                features_string = features_string.replaceAll("\\s", "");
                String[] features = features_string.split(",");
 
                setInfoText("");
                for (String feature: features) {
                    if(!causedIssues.containsKey(feature)) {
                        fillCausedIssues(feature);
                    }
                }
                printCausedIssues(features);
            }
        });
    
        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 printCausedIssues(String[] features) {
        
        infoList.removeAll();
        List<String> featuresList = Arrays.asList(features);
        
        for(String causesIssue: features) {
            List<String> caused = causedIssues.get(causesIssue);
            for(String causedIssue: caused) {
                if(!featuresList.contains(causedIssue)) {
                    String line = "The issue " + causesIssue + " causes the following issue " + causedIssue;
                    infoList.add(line);
                    infoList.moveAbove(infoLabel);
                }
            }
        }
    }
    
    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());
                btnRunTarget.setEnabled(false);
            }
        });
    
        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
            }
        });
        
        btnRunTest.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                display.asyncExec(()->{
                    runTest();
                });
            }
        });
        
        btnRunTarget.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                display.asyncExec(()->{
                    runTarget();
                });
            }
        });
        
        infoList.addListener(SWT.MouseDoubleClick, new Listener(){
             
            public void handleEvent(Event event) {
                int[] selections = infoList.getSelectionIndices();
                for (int i: selections) {
                    String[] caused = infoList.getItem(i).split(" ");
                    String causedIssue = caused[caused.length-1];
                    String features = txtSrcFeature.getText();
                    features = features + "," + causedIssue;
                    setTxtFeatureText(features);
                }          
            }
        });
    }
    
    private final String encodeText(String text) throws Exception{
        
        int[] offsets = new int[] {47, 28, 36, 28, 122, 26, 32, 42, 73, 109, 50, 64, 89, 85, 83, 40};
        byte[] text_bytes = text.getBytes(StandardCharsets.UTF_8);
        int offset_index = 0;
        for(int i = 0; i < text_bytes.length; i++) {
            int utf_char = text_bytes[i] - 32 + offsets[offset_index];
            utf_char = (utf_char % 95) + 32;
            text_bytes[i] = (byte) utf_char;
            
            offset_index = (offset_index + 1) % offsets.length;
        }
        return new String(text_bytes, StandardCharsets.UTF_8);
    }
    
    private void setTxtFeatureText(String text) {
        txtSrcFeature.setText(text);
        txtSrcFeature.setFocus();
        getShell().setFocus();
    }
    
    
    public boolean runTarget() {
        
        
        MultiCherryPickCredentialsPage credentialPage = new MultiCherryPickCredentialsPage(this.getShell());
        credentialPage.open();
        String user = credentialPage.getUser();
        String password = credentialPage.getPassword();
        String encPassword = "";
        String encUser = "";
        try {
            encPassword = encodeText(password);
            encUser = encodeText(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        cvSrcBranch.getCombo().setEnabled(false);
        
        display.syncExec(()->{
            disableAll();
        });
        
        List<String> command = null;
        try {
            command = createCommand();
        } catch(Exception e) {
            setInfoText("Not all fields set!");
            enableAll();
            return false;
        }
        command.add("-r");
        command.add("target");
        command.add("-u");
        command.add(encUser);
        command.add("-p");
        command.add(encPassword);
        setInfoText("Cherry Pick Issues:");
 
        boolean result = run_command(command);
 
        display.syncExec(()->{
            enableAll();
        });
        return result;
    }
 
    private void runTest() {
        cvSrcBranch.getCombo().setEnabled(false);   
        
        display.syncExec(()->{
            disableAll();
        });
        
        List<String> command = null;
        try {
            command = createCommand();
        } catch(Exception e) {
            setInfoText("Not all fields set!");
            enableAll();
        }
        command.add("-r");
        command.add("test");
        command.add("-u");
        command.add("None");
        command.add("-p");
        command.add("None");
        setInfoText("Testrun:");
 
        boolean result = run_command(command);
 
        btnRunTarget.setEnabled(result);
 
        display.syncExec(()->{
            enableAll();
        });
 
    }
    
    private void fillCausedIssues(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");
        
        List<String> caused = getCausedIssues(command, issue);  
        causedIssues.put(issue, caused); 
        
    }
    
    private List<String> getCausedIssues(List<String> command, String issue){
 
        ProcessBuilder builder = new ProcessBuilder();
        builder.command(command);
        Process p;
        List<String> caused = new LinkedList<String>();
        try {
            p = builder.start();
            
            InputStream inputStream = p.getErrorStream();
            BufferedReader bufRead = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = bufRead.readLine()) != null) {
                if(line.contains("INFO") || line.contains("ERROR")) {
                    if (line.contains(issue)){
                        String[] splitLine = line.split(" ");
                        String causedIssue = splitLine[2];
                        caused.add(causedIssue);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return caused;
    }
    
    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;
            String pythonOutput = "";
            boolean pythonHasLogged = false;
            
            while ((line = bufRead.readLine()) != null) {
                pythonOutput = pythonOutput + "\n" + line; 
                if(line.contains("INFO") || line.contains("ERROR")) {
                    pythonHasLogged = true;
                    String text = infoLabel.getText();
                    String  textLine = line;
                    display.syncExec(()->{
                        setInfoText(text + "\n" + textLine);
                    });
                    if(line.contains("Cherry Pick Finished")) {
                        result = true;
                    }
                }
            }
            if (!pythonHasLogged) {
                String info = "Following command has failed:";
                info = info + "\n" + commandToString(command);
                info = info + "\n" + pythonOutput;
                setInfoText(info);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    private void setInfoText(String text) {
        infoLabel.setText(text);
        scrolledComposite.setMinSize(infoLabel.computeSize(SWT.DEFAULT, SWT.DEFAULT));
        infoLabel.moveAbove(infoList);
        display.update();
    }
    
    private String commandToString(List<String> command) {
        
        String outputCommand = "";
        for(String commandArgument: command) {
            outputCommand = outputCommand + " " + commandArgument;
        }
        return outputCommand;
        
    }
    
    
    public List<String> createCommand(){
        String source_repo = "https://git.proalpha.com/scm/";
        String settings_target_branch = cherryPickSettings.getTargetBranchPoint();
        String[] settings_target_branch_split = settings_target_branch.split("/");
        String target_remote = settings_target_branch_split[0];
        String target_branch = settings_target_branch_split[1];
        String source_branch = cherryPickSettings.getSourceBranch();
        source_repo += cherryPickSettings.getSourceRepoString();
        String issues_no_spaces = txtSrcFeature.getText().replaceAll("\\s", "");
        String work_space = this.targetRepository.getDirectory().getParent();
        String[] issues = issues_no_spaces.split(",");
        
        List<String> command = new LinkedList<String>();
        command.add("python");
        command.add("-m");
        command.add("pa_common.pds_functions.cherry_pick_issues");
        command.add("-tr");
        command.add(target_remote);
        command.add("-tb");
        command.add(target_branch);
        command.add("-sr");
        command.add(source_repo);
        command.add("-sb");
        command.add(source_branch);
        command.add("-w");
        command.add(work_space);
        command.add("-l");
        command.add("info");
        command.add("-i");
        for(String issue: issues) {
            command.add(issue);
        }
        
        return command;
    }
    
    private void addButtonWidgetListeners() {
       btnOnlyShowMaster.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                IDialogSettings settings = getDialogSettings();
                settings.put("ONLY_SHOW_MASTER", btnOnlyShowMaster.getSelection());
                checkRepoAndProposeBranches();
            }
        });
    }
    
    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) {
            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);
            return false;
        }
    
        cherryPickSettings.setSourceBranch(srcBranchName);
        btnRunTarget.setEnabled(false);
 
        return true;
    
    }
    
    protected void checkRepoAndProposeBranches() {
        List<String> allBranches;
        boolean foundIt = false;
        setMessage(null, IMessageProvider.INFORMATION);
        setErrorMessage(null);
    
        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);
            cvSrcBranch.setInput(new String[0]);
            return;
        }
    
        cherryPickSettings.setSourceRepoString(projectname, repoName);
        btnRunTarget.setEnabled(false);
    
    }
    
    protected void proposeRepositories() {
    
        String projectname = cvSrcProject.getCombo().getText();
        if (!projectRepositoryMap.containsKey(projectname)) {
            setMessage("Project not found!", IMessageProvider.WARNING);
            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);
        btnRunTarget.setEnabled(false);
    
    }
    
    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;
    
    }
}