Exemple #1
0
        public static async Task <GitResult> RunGit(string path, string gitCommand)
        {
            var result = new GitResult();
            await Task.Run(() =>
            {
                ProcessStartInfo procStartInfo = new ProcessStartInfo(_pathToGit, gitCommand)
                {
                    WorkingDirectory       = path,
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,
                    UseShellExecute        = false,
                    WindowStyle            = ProcessWindowStyle.Hidden,
                    CreateNoWindow         = true
                };
                using (var proc = new Process())
                {
                    proc.StartInfo = procStartInfo;
                    proc.Start();
                    var output    = proc.StandardOutput.ReadToEnd();
                    var error     = proc.StandardError.ReadToEnd();
                    result.Error  = error;
                    result.Output = output;
                    proc.WaitForExit();
                    proc.Close();
                }
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #2
0
        public async Task <GitResult> CommitAsync(string path, string message)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = $@"commit -m ""{message}""";
                result         = await RunGit(path, gitCommand).ConfigureAwait(false);
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #3
0
        public async Task <GitResult> StatusAsync(string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = $"status";
                result         = await RunGit(path, gitCommand).ConfigureAwait(false);
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #4
0
        public async Task <GitResult> GetAllCommitsForBranch(string path, string nameBranch)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = $@"log {nameBranch}";
                result         = await RunGit(path, gitCommand).ConfigureAwait(false);
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #5
0
        public async Task <GitResult> RemoteAsync(string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = $"remote -v";
                result         = await RunGit(path, gitCommand);
            });

            return(result);
        }
Exemple #6
0
        public async Task <GitResult> MergeAsync(string path, string branchName)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = $"merge {branchName}";
                result         = await RunGit(path, gitCommand);
            });

            return(result);
        }
Exemple #7
0
        public async Task <GitResult> GetBranchesAsync(string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = "branch -a";
                result         = await RunGit(path, gitCommand);
            });

            return(result);
        }
Exemple #8
0
        public async Task <GitResult> LastCommitAsync(string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                string gitCommand = "log -1";
                result            = await RunGit(path, gitCommand);
            });

            return(result);
        }
Exemple #9
0
        public async Task <GitResult> StageAsync(string path, IEnumerable <string> files)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var file       = string.Join(" ", files);
                var gitCommand = $"add " + file;
                result         = await RunGit(path, gitCommand).ConfigureAwait(false);
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #10
0
        public async Task <GitResult> GetCurrentBranchAsync(string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand = "rev-parse --abbrev-ref HEAD";
                result         = await RunGit(path, gitCommand);
                result.Output  = result.Output.Trim('\n');
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #11
0
        public async Task <GitResult> PushAsync(string url, string path)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var conifrm    = $"{_login}:{_password}@";
                url            = url.Insert(8, conifrm);
                var gitCommand = $@"push -u {url}";
                result         = await RunGit(path, gitCommand).ConfigureAwait(false);
            }).ConfigureAwait(false);

            return(result);
        }
Exemple #12
0
        public async Task <GitResult> CreateBranchAsync(string path, string name, bool isCheckout)
        {
            var result = new GitResult();
            await Task.Run(async() =>
            {
                var gitCommand  = $"checkout -b {name}";
                var gitCommand2 = $"branch {name}";
                if (isCheckout)
                {
                    result = await RunGit(path, gitCommand);
                }
                result = await RunGit(path, gitCommand2);
            });

            return(result);
        }
Exemple #13
0
        public async Task <bool> IsExistPull(string path)
        {
            var result1 = new GitResult();
            var result2 = new GitResult();
            var temp1   = string.Empty;
            var temp2   = string.Empty;
            var branch  = await GetCurrentBranchAsync(path).ConfigureAwait(false);

            await Task.Run(async() =>
            {
                var gitCommand1 = "rev-parse HEAD";
                var gitCommand2 = $"rev-parse remotes/origin/{branch.Output}";
                result1         = await RunGit(path, gitCommand1).ConfigureAwait(false);
                result2         = await RunGit(path, gitCommand2).ConfigureAwait(false);
                temp1           = result1.Output.Trim(' ', '\n', '\t');
                temp2           = result2.Output.Trim(' ', '\n', '\t');
            });

            return(temp1 == temp2);
        }