Exemplo n.º 1
0
		public void IsGitDir_With_Valid_GitDir_Should_Return_True ()
		{
			SetupGitRepos (InitialGitStatus.BareAheadOfHome);
			var configEntry = MakeConfigEntry ();
			var gitService = new GitService ();
			Assert.IsTrue(gitService.IsGitDir(configEntry.Local));
		}
Exemplo n.º 2
0
		public void API_Exploring_Getting_MoreInfos_From_NGitPullResponse()
		{
			SetupGitRepos (InitialGitStatus.BareAheadOfHome);
			var configEntry = MakeConfigEntry ();
			var gitService = new GitService ();

			// Method under test:
//			PullResult result = gitService.Pull(configEntry);
//
//
//			Assert.IsTrue (result.IsSuccessful());
//
//			// MergeResult
//			MergeCommandResult mergeCommandResult = result.GetMergeResult();
//			// MergeStatus
//			MergeStatus mergeStatus = mergeCommandResult.GetMergeStatus();
//			Assert.IsTrue (mergeStatus.IsSuccessful());
//			// MergeConflicts
////			IDictionary<string, int[][]> conflicts = mergeCommandResult.GetConflicts();
////			//
////			NGit.ObjectId[] mergedCommits = mergeCommandResult.GetMergedCommits();
//
//			// Fetched From
//			string fetchedFrom = result.GetFetchedFrom();
//			Assert.AreEqual ("origin", fetchedFrom);
//
//			// FetchResults
//			Assert.IsNotNull(result.GetFetchResult());
//			NGit.Transport.FetchResult fetchResult = result.GetFetchResult();
//			Assert.IsNotNullOrEmpty(fetchResult.GetMessages());

		}
Exemplo n.º 3
0
		public void Pull_With_ValidGitDirs_ShouldNot_ThrowException ()
		{
			var result = SetupGitRepos (InitialGitStatus.BareAheadOfHome);
			Assert.IsTrue (result.Success);

			var service = base.InitJsonService();
			var config = service.SyncConfig;

			var gitService = new GitService ();
			foreach (var entry in config.Entries) {
				Assert.DoesNotThrow(() => gitService.Pull (entry));
				Assert.DoesNotThrow(() => gitService.Push (entry));
			}
		}
Exemplo n.º 4
0
Arquivo: Lazy.cs Projeto: silvath/lazy
        public void ShowBranchs(string repositoryName)
        {
            RepositoryVO  repository = this.Solution.GetRepositoryByName(repositoryName);
            List <string> branchs    = GitService.ListBranchs(repository);
            string        branch     = WindowManager.ShowDialogList("Branchs", branchs);

            if (string.IsNullOrEmpty(branch))
            {
                return;
            }
            GitService.UpdateStatus(this.Solution, true);
            if (!EnsureHasNoChanges())
            {
                return;
            }
            GitService.CheckoutBranch(this.Solution, branch);
            GitService.UpdateStatus(this.Solution, true);
            this.RefreshUI();
        }
Exemplo n.º 5
0
        /// <summary>更新仓库统计信息</summary>
        /// <param name="project"></param>
        private void UpdateRepo(String owner, String project)
        {
            using (var git = new GitService(project))
            {
                // 修正提交数、分支、参与人等
                var commit    = git.Repository.Head.Tip;
                var ancestors = git.Repository.Commits.QueryBy(new CommitFilter {
                    IncludeReachableFrom = commit
                });

                var set = new HashSet <String>();
                var cms = 0;
                var cts = 0;
                foreach (var ancestor in ancestors)
                {
                    cms++;
                    if (set.Add(ancestor.Author.ToString()))
                    {
                        cts++;
                    }
                }

                var repo = NewLife.GitCandy.Entity.Repository.FindByOwnerAndName(owner, project);
                if (repo != null)
                {
                    if (cms > 0)
                    {
                        repo.Commits = cms;
                    }
                    repo.Branches = git.Repository.Branches.Count();
                    if (cts > 0)
                    {
                        repo.Contributors = cts;
                    }
                    var size = 0L;
                    repo.Files      = FilesInCommit(commit, out size);
                    repo.Size       = size;
                    repo.LastCommit = commit.Committer.When.LocalDateTime;

                    repo.SaveAsync();
                }
            }
        }
Exemplo n.º 6
0
        public ActionResult Commits(String owner, String name, String path, Int32?page)
        {
            using (var git = new GitService(owner, name))
            {
                var model = git.GetCommits(path, page ?? 1, UserConfiguration.Current.Commits);
                //if (model == null)
                //    throw new HttpException((int)HttpStatusCode.NotFound, String.Empty);

                ViewBag.Pager = Pager.Items(model.ItemCount)
                                .PerPage(UserConfiguration.Current.Commits)
                                .Move(model.CurrentPage)
                                .Segment(5)
                                .Center();

                model.Owner = owner;
                model.Name  = name;
                return(View(model));
            }
        }
Exemplo n.º 7
0
        public ActionResult Commits(string name, string path, int?page)
        {
            using (var git = new GitService(name))
            {
                var model = git.GetCommits(path, page ?? 1, UserConfiguration.Current.NumberOfCommitsPerPage);
                if (model == null)
                {
                    throw new HttpException((int)HttpStatusCode.NotFound, string.Empty);
                }

                ViewBag.Pager = Pager.Items(model.ItemCount)
                                .PerPage(UserConfiguration.Current.NumberOfCommitsPerPage)
                                .Move(model.CurrentPage)
                                .Segment(5)
                                .Center();

                model.RepositoryName = name;
                return(View(model));
            }
        }
Exemplo n.º 8
0
        public ActionResult Edit(SettingModel model)
        {
            var needRestart = false;

            if (ModelState.IsValid)
            {
                var verify = GitService.VerifyGit(model.GitExePath);
                if (!verify)
                {
                    ModelState.AddModelError("GitExePath", string.Format(SR.Validation_Filepath, "GitExePath", "git.exe"));
                    return(View(model));
                }

                var config = UserConfiguration.Current;

                needRestart = (config.CachePath != model.CachePath);

                config.IsPublicServer          = model.IsPublicServer;
                config.ForceSsl                = model.ForceSsl;
                config.SslPort                 = model.SslPort;
                config.LocalSkipCustomError    = model.LocalSkipCustomError;
                config.AllowRegisterUser       = model.AllowRegisterUser;
                config.AllowRepositoryCreation = model.AllowRepositoryCreation;
                config.RepositoryPath          = model.RepositoryPath;
                config.CachePath               = model.CachePath;
                config.GitExePath              = model.GitExePath;
                config.NumberOfCommitsPerPage  = model.NumberOfCommitsPerPage;
                config.NumberOfItemsPerList    = model.NumberOfItemsPerList;
                config.Save();
                ModelState.Clear();
            }

            Logger.Info("Settings updated by {0}#{1}", Token.Username, Token.UserID);

            if (needRestart)
            {
                HttpRuntime.UnloadAppDomain();
            }

            return(View(model));
        }
Exemplo n.º 9
0
        public ActionResult Archive(String owner, String name, String path)
        {
            using (var git = new GitService(owner, name))
            {
                var repo = Repository.FindByOwnerAndName(owner, name);
                if (repo != null)
                {
                    repo.Downloads++;
                    repo.Save();
                }

                var cacheFile = git.GetArchiveFilename(path, out var referenceName);
                if (cacheFile == null)
                {
                    throw new HttpException((Int32)HttpStatusCode.NotFound, String.Empty);
                }

                var filename = name + "-" + referenceName;
                return(File(cacheFile, "application/zip", filename + ".zip"));
            }
        }
        public void Unsure_A_Propperly_Formatted_User_Is_Returned()
        {
            var logger     = A.Fake <ILogger>();
            var restClient = A.Fake <IRestClient>();

            var avatarUrl = "https://avatars.githubusercontent.com/u/78586?v=3";
            var name      = "Rob Conery";
            var location  = "Seattle, WA";

            A.CallTo(() => restClient.Execute(null)).WithAnyArguments().Returns(UserJson());

            var userResult = new GitService(logger, restClient).GetGitUser(new GetGitUserRequest("Username"));

            Assert.IsNotNull(userResult);
            Assert.IsNotNull(userResult.User);
            Assert.AreEqual(avatarUrl, userResult.User.AvatarUrl);
            Assert.AreEqual(name, userResult.User.Name);
            Assert.AreEqual(location, userResult.User.Location);

            A.CallTo(() => logger.Error(string.Empty)).MustNotHaveHappened();
        }
Exemplo n.º 11
0
        public ActionResult Blob(String owner, String name, String path)
        {
            using (var git = new GitService(owner, name))
            {
                var model = git.GetBlob(path);
                if (model == null)
                {
                    throw new HttpException((Int32)HttpStatusCode.NotFound, String.Empty);
                }

                // 修正Markdown
                if (model.Name.EndsWithIgnoreCase(".md"))
                {
                    model.FixMarkdown($"/{owner}/{name}");
                }

                model.Name = name;

                return(View(model));
            }
        }
Exemplo n.º 12
0
        public void Branch_With_Remote()
        {
            using (var temp = new TempRepository())
            {
                var repository  = temp.Repository;
                var owner       = "owner";
                var remoteName  = "remoteName";
                var remote      = repository.Network.Remotes.Add(remoteName, $"https://github.com/{owner}/VisualStudio");
                var localBranch = repository.Head;
                repository.Branches.Update(temp.Repository.Head,
                                           b => b.Remote         = remote.Name,
                                           b => b.UpstreamBranch = localBranch.CanonicalName);
                var path            = temp.Directory.FullName;
                var target          = new GitService(new RepositoryFacade());
                var localRepository = target.CreateLocalRepositoryModel(path);

                var branch = target.GetBranch(localRepository);

                Assert.That(branch.TrackedRemoteName, Is.EqualTo(remoteName));
            }
        }
Exemplo n.º 13
0
        public void Master_Branch()
        {
            using (var temp = new TempRepository())
            {
                var signature = new Signature("Me", "*****@*****.**", DateTimeOffset.Now);
                temp.Repository.Commit("First", signature, signature);
                var expectSha = temp.Repository.Head.Tip.Sha;
                var path      = temp.Directory.FullName;
                var target    = new GitService(new RepositoryFacade());

                var localRepository = target.CreateLocalRepositoryModel(path);
                var branch          = target.GetBranch(localRepository);

                Assert.That(branch.Name, Is.EqualTo("master"));
                Assert.That(branch.DisplayName, Is.EqualTo("master"));
                Assert.That(branch.Id, Is.EqualTo("/master")); // We don't know owner
                Assert.That(branch.IsTracking, Is.EqualTo(false));
                Assert.That(branch.TrackedSha, Is.EqualTo(null));
                Assert.That(branch.Sha, Is.EqualTo(expectSha));
            }
        }
Exemplo n.º 14
0
        public async Task HeadAndRemoteOnSameCommit_ReturnCommitSha()
        {
            using (var temp = new TempDirectory())
            {
                string expectSha;
                var    dir = temp.Directory.FullName;
                using (var repo = new Repository(Repository.Init(dir)))
                {
                    AddCommit(repo); // First commit
                    var commit = AddCommit(repo);
                    expectSha = commit.Sha;
                    AddTrackedBranch(repo, repo.Head, commit);
                }

                var target = new GitService(new RepositoryFacade());

                var sha = await target.GetLatestPushedSha(dir).ConfigureAwait(false);

                Assert.That(sha, Is.EqualTo(expectSha));
            }
        }
Exemplo n.º 15
0
        public ActionResult Contributors(String owner, String name, String path)
        {
            using (var git = new GitService(name))
            {
                var model = git.GetContributors(path);
                if (model == null)
                {
                    throw new HttpException((int)HttpStatusCode.NotFound, String.Empty);
                }

                // 修正文件数
                var repo = Repository.FindByOwnerAndName(owner, name);
                if (repo != null)
                {
                    repo.Files = model.Statistics.Current.NumberOfFiles;
                    repo.SaveAsync();
                }

                return(View(model));
            }
        }
Exemplo n.º 16
0
        public ActionResult Edit(String owner, String name, RepositoryModel model)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new HttpException((Int32)HttpStatusCode.NotFound, String.Empty);
            }

            if (ModelState.IsValid)
            {
                if (!RepositoryService.Update(owner, model))
                {
                    throw new HttpException((Int32)HttpStatusCode.NotFound, String.Empty);
                }
                using (var git = new GitService(owner, name))
                {
                    git.SetHeadBranch(model.DefaultBranch);
                }
                return(RedirectToAction("Detail", new { name }));
            }

            return(View(model));
        }
Exemplo n.º 17
0
        public ActionResult Archive(string name, string path, string eol = null)
        {
            using (var git = new GitService(name))
            {
                string newline = null;
                switch (eol)
                {
                case "LF":
                    newline = "\n";
                    break;

                case "CR":
                    newline = "\r";
                    break;

                case "CRLF":
                    newline = "\r\n";
                    break;

                default:
                    eol = null;
                    break;
                }

                string referenceName;
                var    cacheFile = git.GetArchiveFilename(path, newline, out referenceName);
                if (cacheFile == null)
                {
                    throw new HttpException((int)HttpStatusCode.NotFound, string.Empty);
                }

                var filename = name + "-" + referenceName;
                if (eol != null)
                {
                    filename += "-" + eol;
                }
                return(File(cacheFile, "application/zip", filename + ".zip"));
            }
        }
Exemplo n.º 18
0
        public Result Apply(string markdown, Context context)
        {
            var pattern = @"\{\{\W*GIT_VERSIONS\W*\}\}";
            var result  = markdown;

            if (Regex.IsMatch(markdown, pattern, RegexOptions.IgnoreCase))
            {
                var changes = GitService.GetVersions(_sourceFilePath, _ignoreGitCommitsSince).ToList();

                string replacement;
                if (changes.Any())
                {
                    replacement = "| Datum | Person | Version | Änderung" + Environment.NewLine + "|-|-|-|-|";

                    for (var i = 0; i < changes.Count; i++)
                    {
                        var change = changes[i];
                        // if we have the same message multiple times in a row, just use the latest commit
                        if (i > 0 && (changes[i - 1].Message ?? "").Equals(change.Message, StringComparison.OrdinalIgnoreCase))
                        {
                            continue;
                        }

                        replacement += Environment.NewLine + $"| {change.Date.ToString("dd. MM. yyyy", new CultureInfo("de-DE")).Replace(" ", "&nbsp;")} |" +
                                       $" {change.Author.Replace(" ", "&nbsp;")} |" +
                                       $" {change.ShaShort} |" +
                                       $" {change.MessageShort} {(string.IsNullOrWhiteSpace(change.Message) ? "" : $"<span class=\"git-version-details\"><br />{change.Message.Substring(change.MessageShort.Length).Replace("\r", "").Replace("\n", "").Trim()}")}</span>";
                    }
                }
                else
                {
                    replacement = "{{!}} Dieses Dokument befindet sich nicht in Versionskontrolle.";
                }

                result = Regex.Replace(result, pattern, replacement, RegexOptions.IgnoreCase);
            }

            return(new Result(result, context));
        }
        public void Unsure_A_Propperly_Formatted_UserRepository_Is_Returned()
        {
            var logger     = A.Fake <ILogger>();
            var restClient = A.Fake <IRestClient>();

            var jsonResult = RepositoryJson();

            A.CallTo(() => restClient.Execute(null)).WithAnyArguments().Returns(jsonResult);

            var userRepository = new GitService(logger, restClient).GetGitUserRepositories(new GetGitRepositoriesRequest()
            {
                Username = "******"
            });

            Assert.IsNotNull(userRepository);
            Assert.IsNotNull(userRepository.Repositories.Any());

            foreach (var repo in userRepository.Repositories)
            {
            }
            A.CallTo(() => logger.Error(string.Empty)).MustNotHaveHappened();
        }
Exemplo n.º 20
0
        public async Task <IActionResult> GetTreeView(string userName, string repoName, string id, string path)
        {
            XTrace.UseConsole();

            var DCRepositoriesService = Ioc.Create <IDCRepositoriesService>();

            repoName = Path.Combine(userName, repoName);
            Repository repo   = DCRepositoriesService.GetRepository(repoName);
            Commit     commit = repo.Branches[id]?.Tip ?? repo.Lookup <Commit>(id);

            if (commit == null)
            {
                return(View("Init"));
            }

            using (var git = new GitService(repoName))
            {
                if (!path.IsNullOrEmpty())
                {
                    path = id + "/" + path;
                }
                var model = await git.GetTree(path);

                if (model == null)
                {
                    return(NotFound());
                }

                if (model.Entries == null && model.ReferenceName != "HEAD")
                {
                    return(RedirectToAction("Tree", new { path = model.ReferenceName }));
                }

                XTrace.WriteLine(model.ToJson());

                return(View("Tree", model));
            }
        }
Exemplo n.º 21
0
        /// <inheritdoc/>
        public Action <IApplicationBuilder> Configure(Action <IApplicationBuilder> next)
        {
            if (ApplicationOptions.Username != null || ApplicationOptions.Password != null)
            {
                if (ApplicationOptions.Username == null)
                {
                    throw new ApplicationException("Error in configuration: Password set without Username");
                }
                else if (ApplicationOptions.Password == null)
                {
                    throw new ApplicationException("Error in configuration: Username set without Password");
                }
            }

            try
            {
                YamlConfigurationService.LoadConfiguration();

                var repositories = YamlConfigurationService.Repositories ?? Enumerable.Empty <RepositoryDescriptor>();

                foreach (var repository in repositories)
                {
                    Logger.LogInformation("Initializing repository '{repository}'", repository.Name);
                    GitService.InitializeRepository(repository);
                }

                NotificationsService.ConfigureRepositories(YamlConfigurationService.YamlConfiguration?.RefreshInterval ?? 5, repositories);
            }
            catch (Exception exc)
            {
                throw new ApplicationException("Error loading configuration: " + exc.Message +
                                               (exc.InnerException is null
                        ? string.Empty
                        : $" ({exc.InnerException.Message})"));
            }

            return(next);
        }
Exemplo n.º 22
0
Arquivo: Lazy.cs Projeto: silvath/lazy
 public void CreateBranch()
 {
     if (this.Solution == null)
     {
         return;
     }
     if (this.WorkItem == null)
     {
         MessageBox.ErrorQuery(50, 7, "VSTS", "You must select a work item first", "Ok");
         return;
     }
     if (!EnsureHasNoChanges())
     {
         return;
     }
     WindowManager.ShowLog();
     GitService.CheckoutBranch(this.Solution, this.BranchBase);
     GitService.Pull(this.Solution);
     GitService.CreateBranch(this.Solution, this.WorkItem);
     GitService.UpdateStatus(this.Solution, true);
     WindowManager.CloseLog();
     this.RefreshUI();
 }
        /// <summary>
        /// This is called on a background thread. Do not do synchronous GetService calls here.
        /// </summary>
        /// <param name="active"></param>
        /// <param name="refresh"></param>
        async void UIContextChanged(bool active, bool refresh)
        {
            Debug.Assert(ServiceProvider != null, "UIContextChanged called before service provider is set");
            if (ServiceProvider == null)
            {
                return;
            }

            if (active)
            {
                if (ActiveRepo == null || refresh)
                {
                    ActiveRepo = await System.Threading.Tasks.Task.Run(() =>
                    {
                        var repos = GitService.ActiveRepositories;
                        // Looks like this might return null after a while, for some unknown reason
                        // if it does, let's refresh the GitService instance in case something got wonky
                        // and try again. See issue #23
                        if (repos == null)
                        {
                            log.Error("Error 2001: ActiveRepositories is null. GitService: '{GitService}'", GitService);
                            GitService.Refresh(ServiceProvider);
                            repos = GitService.ActiveRepositories;
                            if (repos == null)
                            {
                                log.Error("Error 2002: ActiveRepositories is null. GitService: '{GitService}'", GitService);
                            }
                        }
                        return(repos?.FirstOrDefault());
                    });
                }
            }
            else
            {
                ActiveRepo = null;
            }
        }
Exemplo n.º 24
0
        private SelectableAction[] GetActions(string path)
        {
            var actions = new List <SelectableAction>
            {
                new SelectableAction("Open", () => FolderService.OpenLocation(path)),
            };

            //if (false) // Disable until I can figure it out
            //{
            //    actions.Add(new SelectableAction("Terminal", () => TerminalService.OpenTerminal(path)));
            //}

            var hasGit = GitService.TryGetRemoteGitLocation(path, out string uri);

            if (hasGit)
            {
                actions.Add(new SelectableAction("Web", () => StartProgramService.StartProgram(uri)));
            }

            foreach (var type in m_programTypesToStart)
            {
                actions.Add(new SelectableAction(type, () => StartProgramService.StartProgramOfType(type, path, true)));
            }

            foreach (var type in m_programTypesTopFolderToStart)
            {
                actions.Add(new SelectableAction(type, () => StartProgramService.StartProgramOfType(type, path, false)));
            }

            foreach (var script in m_scripts)
            {
                actions.Add(new SelectableAction(script.Key, () => StartProgramService.RunScript(script, path)));
            }

            return(actions.ToArray());
        }
Exemplo n.º 25
0
 private void Button_Click(object sender, RoutedEventArgs e)
 {
     if (string.IsNullOrEmpty(TokenInputBox.Text))
     {
         MessageBox.Show("No token");
     }
     else
     {
         HttpClient client = new HttpClient();
         client.BaseAddress = new Uri("https://api.github.com");
         var token   = TokenInputBox.Text;
         var service = new GitService(token);
         if (service.AuthenticateUser(token))
         {
             Home home = new Home(token);
             home.Show();
             this.Close();
         }
         else
         {
             MessageBox.Show("Bad Token");
         }
     }
 }
Exemplo n.º 26
0
        public async Task BehindRemoteBranch_ReturnRemoteCommitSha(string remoteName, bool expectFound)
        {
            using (var temp = new TempDirectory())
            {
                string expectSha;
                var    dir = temp.Directory.FullName;
                using (var repo = new Repository(Repository.Init(dir)))
                {
                    AddCommit(repo); // First commit
                    var commit1 = AddCommit(repo);
                    var commit2 = AddCommit(repo);
                    var branchA = repo.Branches.Add("branchA", commit2);
                    repo.Reset(ResetMode.Hard, commit1);
                    expectSha = expectFound ? commit1.Sha : null;
                    AddTrackedBranch(repo, branchA, commit2, remoteName: remoteName);
                }

                var target = new GitService(new RepositoryFacade());

                var sha = await target.GetLatestPushedSha(dir).ConfigureAwait(false);

                Assert.That(sha, Is.EqualTo(expectSha));
            }
        }
Exemplo n.º 27
0
        public async Task BranchForkedFromMaster_ReturnRemoteCommitSha()
        {
            using (var temp = new TempDirectory())
            {
                string expectSha;
                var    dir = temp.Directory.FullName;
                using (var repo = new Repository(Repository.Init(dir)))
                {
                    AddCommit(repo); // First commit
                    var commit1 = AddCommit(repo);
                    AddTrackedBranch(repo, repo.Head, commit1);
                    var branch = repo.Branches.Add("branch", commit1);
                    Commands.Checkout(repo, branch);
                    var commit2 = AddCommit(repo);
                    expectSha = commit1.Sha;
                }

                var target = new GitService(new RepositoryFacade());

                var sha = await target.GetLatestPushedSha(dir).ConfigureAwait(false);

                Assert.That(sha, Is.EqualTo(expectSha));
            }
        }
Exemplo n.º 28
0
        public ActionResult Tree(string name, string path)
        {
            using (var git = new GitService(name))
            {
                var model = git.GetTree(path);
                if (model == null)
                {
                    throw new HttpException((int)HttpStatusCode.NotFound, string.Empty);
                }
                if (model.Entries == null && model.ReferenceName != "HEAD")
                {
                    return(RedirectToAction("Tree", new { path = model.ReferenceName }));
                }

                model.GitUrls        = GetGitUrl(name);
                model.RepositoryName = name;
                if (model.IsRoot)
                {
                    var m = RepositoryService.GetRepositoryModel(name);
                    model.Description = m.Description;
                }
                return(View(model));
            }
        }
Exemplo n.º 29
0
        protected ActionResult ExecutePack(string project, string service)
        {
            Response.Charset     = "";
            Response.ContentType = String.Format(CultureInfo.InvariantCulture, "application/x-{0}-result", service);
            SetNoCache();

            try
            {
                using (var git = new GitService(GitService.GetDirectoryInfo(project).FullName))
                {
                    var svc = service.Substring(4);
                    git.ExecutePack(svc, GetInputStream(), Response.OutputStream);
                }
                return(new EmptyResult());
            }
            catch (RepositoryNotFoundException e)
            {
                throw new HttpException((int)HttpStatusCode.NotFound, string.Empty, e);
            }
            catch (Exception e)
            {
                throw new HttpException((int)HttpStatusCode.InternalServerError, string.Empty, e);
            }
        }
Exemplo n.º 30
0
        public ActionResult Create(RepositoryModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var repo = RepositoryService.Create(model);
                    if (repo != null)
                    {
                        //var success = GitService.CreateRepository(model.Owner, model.Name);
                        var remoteUrl = model.HowInit.EqualIgnoreCase("Import") ? model.RemoteUrl : null;
                        var success   = GitService.CreateRepository(model.Owner, model.Name, remoteUrl);
                        if (!success)
                        {
                            RepositoryService.Delete(Token?.Name, model.Name);
                            repo = null;
                        }
                    }
                    if (repo != null)
                    {
                        return(RedirectToAction("Tree", "Repository", new { owner = model.Owner, name = repo.Name }));
                    }
                }
                catch (ArgumentException ex)
                {
                    //ModelState.AddModelError(ex.ParamName, SR.Repository_AlreadyExists);
                    ModelState.AddModelError(ex.ParamName, ex.Message);
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("", ex);
                }
            }

            return(CreateView(model));
        }
Exemplo n.º 31
0
		public void Push_WithInvalid_GitDirs_Should_ThrowException ()
		{
			var result = SetupGitRepos (InitialGitStatus.BareAheadOfHome);

			Assert.IsTrue (result.Success);

			var configEntry = MakeConfigEntry();
			configEntry.Local = configEntry.Local + "_invalid";
			configEntry.Remote = configEntry.Remote;

			var gitService = new GitService ();
			var ex = Assert.Throws<JGitInternalException>(() => gitService.Push (configEntry));
			Assert.That (ex.InnerException is NoRemoteRepositoryException);
		}
Exemplo n.º 32
0
		public void Push_WithValid_Setup_Should_Return_SuccessTrue()
		{
			var result = SetupGitRepos (InitialGitStatus.HomeAheadOfBare);
			Assert.IsTrue (result.Success);

			var service = base.InitJsonService();
			var config = service.SyncConfig;

			var gitService = new GitService ();
			foreach (var entry in config.Entries) {
				var resultFromPush = gitService.Push (entry);
				Assert.That(resultFromPush.Msg.Contains("STATUS: OK"));
				Assert.IsTrue(resultFromPush.Success);
			}
		}
Exemplo n.º 33
0
 public CreateRepo(GitService git)
 {
     InitializeComponent();
     this.git           = git;
     CloseButton.Click += (s, e) => Close();
 }
Exemplo n.º 34
0
 public GenerateTocHandler(GitService aGitService)
 {
     GitService = aGitService;
 }
Exemplo n.º 35
0
 public RepoViewModel(GitService gitService, IFolderDialogService folderDialogService)
 {
     this.gitService          = gitService;
     this.folderDialogService = folderDialogService;
 }