Пример #1
0
        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);
        }
Пример #2
0
        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);
        }
Пример #3
0
        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();
            }
        }
Пример #4
0
        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);
            }
        }
Пример #5
0
        string GetFilePathForNewFile(IDXVcsRepository repository, string vcsPath, DXVcsBranch currentBranch)
        {
            string testVcsPath = currentBranch.Path;
            string result      = repository.GetFileWorkingPath(testVcsPath) + @"\";

            return(vcsPath.Replace(currentBranch.Path, result));
        }
Пример #6
0
        public void CompareWithCurrentVersion(string filePath)
        {
            IDXVcsRepository repository      = DXVcsRepositoryFactory.Create(Port.VcsServer);
            string           vcsOriginalPath = Port.GetRelativePath(filePath);

            PreviewTarget(repository, vcsOriginalPath, filePath);
        }
Пример #7
0
        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));
        }
Пример #8
0
 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);
 }
Пример #9
0
 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);
     }
 }
Пример #10
0
        void PreviewTarget(IDXVcsRepository repository, string vcsFile, string file)
        {
            string tmpVcsFile = Path.GetTempFileName();

            try {
                repository.GetLatestVersion(vcsFile, tmpVcsFile);
                LaunchDiffTool(tmpVcsFile, file);
            }
            finally {
                File.Delete(tmpVcsFile);
            }
        }
Пример #11
0
        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);
        }
Пример #12
0
 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);
 }
Пример #13
0
 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);
 }
Пример #14
0
        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)));
        }
Пример #15
0
 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");
     }
 }
Пример #16
0
        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);
        }
Пример #17
0
        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);
        }
Пример #18
0
        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);
        }
Пример #19
0
 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);
     }
 }
Пример #20
0
        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);
            }
        }
Пример #21
0
        //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);
            }
        }