public void CompareWithHistoryVersion(string filePath, int leftVersion = 0, int rightVersion = 0, bool compareWithCurrent = true)
{
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string vcsOriginalPath = Port.GetRelativePath(filePath);
PreviewTarget(repository, filePath, vcsOriginalPath, leftVersion, rightVersion, compareWithCurrent);
}
public bool CheckIn(CheckInViewModel checkInViewModel, DXVcsBranch targetBranch, bool isNew)
{
Logger.AddInfo("CheckInCommand. Perform checkin file: " + checkInViewModel.FilePath);
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string filePath = GetFilePathForBranch(checkInViewModel.FilePath, targetBranch);
string vcsOriginalPath = GetMergeVcsPathByTargetPath(filePath, targetBranch);
if (isNew)
{
repository.AddFile(vcsOriginalPath, File.ReadAllBytes(filePath), checkInViewModel.Comment);
}
else
{
repository.CheckInFile(vcsOriginalPath, filePath, checkInViewModel.Comment);
}
if (checkInViewModel.StaysChecked)
{
repository.CheckOutFile(vcsOriginalPath, filePath, checkInViewModel.Comment);
}
}
catch (Exception e) {
Logger.AddError("CheckInCommand. CheckIn failed.", e);
return(false);
}
return(true);
}
void CreateNewFileIfNeeded(IDXVcsRepository repository, string vcsTargetFile, DXVcsBranch branch)
{
if (repository.IsUnderVss(vcsTargetFile))
{
throw new ArgumentException("File is under vss alrealy!");
}
string filePath = GetFilePathForNewFile(repository, vcsTargetFile, branch);
if (File.Exists(filePath))
{
var attr = File.GetAttributes(filePath);
if (attr == FileAttributes.ReadOnly)
{
throw new ArgumentException("File is readonly!");
}
File.Delete(filePath);
}
string dir = Path.GetDirectoryName(filePath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
using (var f = File.Create(filePath)) {
f.Close();
}
}
void PreviewTarget(IDXVcsRepository repository, string file, string vcsFile, int leftVersion = 0, int rightVersion = 0, bool compareWithCurrent = true)
{
string leftFile = Path.GetTempFileName();
string rightFile = Path.GetTempFileName();
try {
if (leftVersion > 0)
{
repository.Get(vcsFile, leftFile, leftVersion);
}
else
{
repository.GetLatestVersion(vcsFile, leftFile);
}
if (compareWithCurrent)
{
CopyFileContent(file, rightFile);
}
else if (rightVersion > 0)
{
repository.Get(vcsFile, rightFile, rightVersion);
}
else
{
repository.GetLatestVersion(vcsFile, rightFile);
}
LaunchDiffTool(leftFile, rightFile);
}
finally {
File.Delete(leftFile);
File.Delete(rightFile);
}
}
string GetFilePathForNewFile(IDXVcsRepository repository, string vcsPath, DXVcsBranch currentBranch)
{
string testVcsPath = currentBranch.Path;
string result = repository.GetFileWorkingPath(testVcsPath) + @"\";
return(vcsPath.Replace(currentBranch.Path, result));
}
public void CompareWithCurrentVersion(string filePath)
{
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string vcsOriginalPath = Port.GetRelativePath(filePath);
PreviewTarget(repository, vcsOriginalPath, filePath);
}
public FileDiffInfo GetFileDiffInfo(string filePath, Action <int, int> progress)
{
IDXVcsRepository dxRepository = DXVcsConnectionHelper.Connect(PortOptions.VcsServer);
MergeHelper helper = new MergeHelper(toolWindowViewModel);
string vcsFile = helper.GetMergeVcsPathByOriginalPath(filePath, PortOptions.MasterBranch);
return(dxRepository.GetFileDiffInfo(vcsFile, progress, SpacesAction.IgnoreAll));
}
public IEnumerable <string> FindWorkingFolders(List <DXVcsBranch> branches)
{
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
return(branches.Select(branch => repository.GetFileWorkingPath(branch.Path)).ToList());
}
catch (Exception e) {
Logger.AddError("GetFilePathForBranch failed.", e);
}
return(null);
}
public void CompareWithPortVersion(string filePath, DXVcsBranch current)
{
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string vcsTargetPath = GetMergeVcsPathByOriginalPath(filePath, current);
PreviewTarget(repository, vcsTargetPath, repository.GetFileWorkingPath(vcsTargetPath));
}
catch (Exception e) {
DXMessageBox.Show(e.Message);
}
}
void PreviewTarget(IDXVcsRepository repository, string vcsFile, string file)
{
string tmpVcsFile = Path.GetTempFileName();
try {
repository.GetLatestVersion(vcsFile, tmpVcsFile);
LaunchDiffTool(tmpVcsFile, file);
}
finally {
File.Delete(tmpVcsFile);
}
}
public MergeState MergeChanges(DXVcsBranch currentBranch, string filePath, string mergePath, bool showPreview)
{
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string tmpOriginalFile = Path.GetTempFileName();
string vcsOriginalPath = Port.GetRelativePath(filePath);
string vcsTargetFile = mergePath == null?GetMergeVcsPathByOriginalPath(filePath, currentBranch) : Port.GetRelativePath(mergePath, currentBranch);
try {
repository.GetLatestVersion(vcsOriginalPath, tmpOriginalFile);
string tmpTargetFile = string.Empty;
try {
tmpTargetFile = repository.GetFileWorkingPath(vcsTargetFile);
}
catch (Exception e) {
Logger.AddError("MergeCommand. Target file error.", e);
return(MergeState.TargetFileError);
}
if (string.IsNullOrEmpty(tmpTargetFile))
{
Logger.AddError("MergeCommand. Target file path is empty.");
return(MergeState.TargetFileError);
}
try {
repository.CheckOutFile(vcsTargetFile, tmpTargetFile, string.Empty);
}
catch (Exception e) {
Logger.AddError("MergeCommand. Check out file error.", e);
return(MergeState.CheckOutFileError);
}
var diff = new FileDiff();
if (!diff.Merge(tmpOriginalFile, filePath, tmpTargetFile))
{
return(MergeState.Conflict);
}
if (showPreview)
{
PreviewTarget(repository, vcsTargetFile, tmpTargetFile);
}
}
finally {
File.Delete(tmpOriginalFile);
}
}
catch {
return(MergeState.UnknownError);
}
return(MergeState.Success);
}
public string GetFilePathForBranch(string path, DXVcsBranch currentBranch)
{
try {
string relativePath = GetMergeVcsPathByOriginalPath(path, currentBranch);
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
return(repository.GetFileWorkingPath(relativePath));
}
catch (Exception e) {
Logger.AddError("GetFilePathForBranch failed.", e);
}
return(string.Empty);
}
public bool IsItemUnderVss(string filePath, DXVcsBranch current)
{
try {
string vcsTargetPath = GetMergeVcsPathByOriginalPath(filePath, current);
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
return(repository.IsUnderVss(vcsTargetPath));
}
catch (Exception e) {
Logger.AddError("IsItemUnderVss failed.", e);
}
return(true);
}
string GetProjectPath(DXVcsBranch currentBranch)
{
if (currentBranch == MasterBranch)
{
return(ProjectFilePath);
}
string vcsPath = GetRelativePath(ProjectFilePath);
string vcsTargetProjectPath = vcsPath.Replace(MasterBranch.Path, currentBranch.Path);
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(VcsServer);
//bug - project file path returns as directory path
return(FindRootProject(repository, repository.GetFileWorkingPath(vcsTargetProjectPath)));
}
public void NavigateToSolution(DXVcsBranch currentBranch, IDteWrapper dte)
{
try {
string filePath = Port.ProjectFilePath;
string vcsFilePath = GetMergeVcsPathByOriginalPath(filePath, currentBranch);
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string targetPath = repository.GetFileWorkingPath(vcsFilePath);
dte.OpenSolution(targetPath);
}
catch {
MessageBox.Show("Can`t navigate to solution");
}
}
public MergeState ManualMerge(DXVcsBranch currentBranch, ManualMergeViewModel mergeModel, Func <bool> showManualMergeUIHandler)
{
try {
string filePath = mergeModel.OriginalFilePath;
string mergePath = mergeModel.TargetFilePath;
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string vcsTargetFile = mergePath == null?GetMergeVcsPathByOriginalPath(filePath, currentBranch) : GetMergeVcsPathByTargetPath(mergePath, currentBranch);
string tmpTargetFile = repository.GetFileWorkingPath(vcsTargetFile);
mergeModel.TargetFilePath = tmpTargetFile;
if (!showManualMergeUIHandler())
{
Logger.AddInfo("ManualMergeCommand. Result = MergeState.None.");
return(MergeState.None);
}
vcsTargetFile = GetMergeVcsPathByTargetPath(mergeModel.TargetFilePath, currentBranch);
string tmpOriginalFile = mergeModel.OriginalFilePath;
tmpTargetFile = repository.GetFileWorkingPath(vcsTargetFile);
if (string.IsNullOrEmpty(tmpTargetFile))
{
Logger.AddInfo("ManualMergeCommand. Result = MergeState.TargetFileError.");
return(MergeState.TargetFileError);
}
repository.CheckOutFile(vcsTargetFile, tmpTargetFile, string.Empty);
if (MergeFileHelper.IsBinaryFile(tmpTargetFile))
{
if (OverwriteFile.Write(tmpOriginalFile, tmpTargetFile))
{
return(MergeState.Success);
}
else
{
return(MergeState.Conflict);
}
}
LaunchDiffTool(tmpOriginalFile, tmpTargetFile);
}
catch (Exception e) {
Logger.AddError("ManualMergeCommand. Unknown error.", e);
Logger.AddInfo("ManualMergeCommand. Result = MergeState.UnknownError.");
return(MergeState.UnknownError);
}
Logger.AddInfo("ManualMergeCommand. Result = MergeState.Success");
return(MergeState.Success);
}
public bool UndoCheckout(string filePath)
{
string vcsFilePath = Port.GetRelativePath(filePath);
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
repository.UndoCheckout(vcsFilePath, filePath);
repository.GetLatestVersion(vcsFilePath, filePath);
FileInfo info = new FileInfo(filePath);
info.IsReadOnly = true;
}
catch {
return(true);
}
return(false);
}
string FindRootProject(IDXVcsRepository repository, string rootPath)
{
string firstCandidate = rootPath + Path.GetFileName(ProjectFilePath);
if (Locator.IsUnderScc(firstCandidate))
{
return(firstCandidate);
}
foreach (var file in Directory.GetFiles(rootPath, "*.sln", SearchOption.AllDirectories))
{
if (Locator.IsUnderScc(file))
{
return(file);
}
}
return(firstCandidate);
}
public void CompareCurrentWithPortVersion(string filePath, DXVcsBranch current)
{
try {
IDXVcsRepository repository = DXVcsRepositoryFactory.Create(Port.VcsServer);
string vcsTargetPath = GetMergeVcsPathByOriginalPath(filePath, current);
if (!repository.IsUnderVss(vcsTargetPath))
{
DXMessageBox.Show("Target is not under vss");
return;
}
string fileTargetPath = repository.GetFileWorkingPath(vcsTargetPath);
PreviewTarget(repository, fileTargetPath, vcsTargetPath, filePath, false);
}
catch (Exception e) {
DXMessageBox.Show(e.Message);
}
}
void PreviewTarget(IDXVcsRepository repository, string file, string vcsFile, string targetFile, bool isNew)
{
string tmpFile = Path.GetTempFileName();
try {
if (!isNew)
{
repository.GetLatestVersion(vcsFile, tmpFile);
}
else
{
CopyFileContent(file, tmpFile);
}
LaunchDiffTool(tmpFile, targetFile);
}
finally {
File.Delete(tmpFile);
}
}
//void ShowExternalBlameInternal(Uri svnFile, int? lineNumber) {
// if (string.IsNullOrEmpty(svnFile.ToString()))
// throw new ArgumentException("svnFile");
// var startInfo = new ProcessStartInfo();
// startInfo.FileName = GetTortoiseProcPath();
// startInfo.Arguments = string.Format("/command:blame /path:{0} /startrev:0 /endrev:-1", svnFile.AbsoluteUri);
// if (lineNumber.HasValue)
// startInfo.Arguments += string.Format(" /line:{0}", lineNumber);
// using (Process process = Process.Start(startInfo)) {
// process.WaitForExit();
// }
//}
void PrepareBlameFileAndShowBlameUI(string filePath, int?lineNumber)
{
string blameFile = null;
string logFile = null;
try {
IDXVcsRepository dxRepository = DXVcsConnectionHelper.Connect(portOptions.VcsServer);
MergeHelper helper = new MergeHelper(options, portOptions);
string vcsFile = helper.GetMergeVcsPathByOriginalPath(filePath, portOptions.MasterBranch);
FileDiffInfo diffInfo = dxRepository.GetFileDiffInfo(vcsFile);
int revision = diffInfo.LastRevision;
IList <IBlameLine> blame = diffInfo.BlameAtRevision(revision);
blameFile = MakeBlameFile(vcsFile, blame);
logFile = MakeLog(blame);
ShowExternalBlameInternal(filePath, vcsFile, blameFile, logFile, revision, lineNumber);
}
finally {
blameFile.Do(File.Delete);
logFile.Do(File.Delete);
}
}
