/// <summary>
/// Gets the repository.
/// </summary>
/// <param name="searchName">Name of the search.</param>
/// <param name="page">The page.</param>
/// <returns>GitHubRepository.</returns>
public GitHubRepository GetRepository(string searchName, int?page)
{
var gitHubRepo = new GitHubRepository();
if (!string.IsNullOrEmpty(searchName))
{
var url = string.Concat(_config.GitHubUrl, "search/repositories?q=", searchName, "&page=", page, "&per_page=10");
var jsonResult = _webClient.GetHttpStringResponse(url);
gitHubRepo = JsonConvert.DeserializeObject <GitHubRepository>(jsonResult);
if (gitHubRepo != null)
{
var count = gitHubRepo.TotalCount;
if (gitHubRepo.TotalCount > 100)
{
count = 100;
}
var pager = new Pager(count, page);
gitHubRepo.Pager = pager;
gitHubRepo.SearchName = searchName;
}
}
return(gitHubRepo);
}
public void GetRepositoryFromId(string username, string repositoryName)
{
var repository = GitHubRepository.GetRepositoryAsync(username, repositoryName).Result;
Assert.NotNull(repository);
Assert.Equal("CS-Notes", repository.Name);
}
/// <summary>
/// Based on a <see cref="GitHubPackDetail"/> array, this method builds out the displayed list of packs.
/// </summary>
/// <param name="packsToDisplay">An optional array of <see cref="GitHubPackDetail"/>. Providing NULL will fetch the list from GitHub</param>
private void PopulateCommunityManagementPackListFromGitHub(GitHubPackDetail[] packsToDisplay)
{
if (packsToDisplay == null || communityManagementPackIndex == null)
{
communityManagementPackIndex = new Models.GitHubRepository();
Task.Run(() => communityManagementPackIndex.PopulateDataFromRepository("DiscoverPacks")).Wait();
packsToDisplay = communityManagementPackIndex.ManagementPacks.Values.ToArray();
}
// Empty the list prior to re-populating
CommunityPackList.Items.Clear();
foreach (GitHubPackDetail communityPack in packsToDisplay.OrderBy(mp => mp.ManagementPackDisplayName))
{
CommunityPackRowTemplate packListTemplateDisplay = new CommunityPackRowTemplate(communityPack);
// Before Adding the Tags, we pass the Tag Selection Event handles through
packListTemplateDisplay.RowFilterTagSelected += FilterTagSelectedByUser;
packListTemplateDisplay.RowFilterTagRemoved += FilterTagRemovedByUser;
packListTemplateDisplay.RowAuthorSelected += FilterAuthorSelected;
// Now populate the tags, they will connect to the above handles.
packListTemplateDisplay.PopulateTagsOnRow();
this.ManagementPackSearchChanged += packListTemplateDisplay.SearchUpdated;
CommunityPackList.Items.Add(packListTemplateDisplay);
}
}
/// <summary>
/// Confirm that the <see cref="communityManagementPackIndex"/> variable is properly populated.
/// If the value is null the data will be re-fetched from GitHub
/// </summary>
private void CheckAndFillGitHubIndex()
{
if (communityManagementPackIndex != null)
{
// We've got data and we can proceeded
return;
}
else
{
// Loop through our GitHub packs an populate a Installed Pack (if applicable)
communityManagementPackIndex = new Models.GitHubRepository();
Task.Run(() => communityManagementPackIndex.PopulateDataFromRepository("InstalledPacks")).Wait();
var managementPackInventory = ManagementGroup.ManagementPacks.GetManagementPacks();
foreach (GitHubPackDetail communityPack in communityManagementPackIndex.ManagementPacks.Values)
{
communityPack.InstalledManagementPack = managementPackInventory.Where(mp => mp.Name == communityPack.ManagementPackSystemName).FirstOrDefault();
if (communityPack.InstalledManagementPack != null)
{
LogManager.Log.WriteTrace(
LogManager.EventType.ExternalDependency,
"Found Matching Management Pack",
communityPack.ManagementPackSystemName);
}
}
}
}
public async Task GetListTopRepositoriesFromLanguages(string language)
{
var repositories = await GitHubRepository.GetTopRepositoriesByLanguageAsync(language);
Assert.NotNull(repositories);
Assert.True(repositories.Count > 0);
}
public async Task <long> CreateRepository(GitHubRepository repository)
{
var gitHubClient = this.GitHubClientProvider.GetGitHubClient();
var autoInit = repository.InitializeWithReadMe;
string licenseTemplate;
switch (repository.License)
{
case GitHubRepositoryLicense.MIT:
licenseTemplate = LicenseHelper.MitLicenseIdentifier;
break;
default:
throw new Exception(EnumerationHelper.UnexpectedEnumerationValueMessage(repository.License));
}
var @private = repository.Visibility == GitHubRepositoryVisibility.Private ? true : false; // Private if private, otherwise public.
var newRepository = new NewRepository(repository.Name)
{
AutoInit = true, // Create with README for immediate checkout.
Description = repository.Description,
LicenseTemplate = licenseTemplate,
Private = @private, // Default is public (private = false).
};
var createdRepository = await gitHubClient.Repository.Create(newRepository);
return(createdRepository.Id);
}
public async Task Create_Branch_Exception()
{
var InputOwner = "foo";
var InputRepo = "bar";
var InputBranchName = "baz";
var InputSha = "qux";
var ExpectedURL = $"https://api.github.com/repos/{InputOwner}/{InputRepo}/git/refs";
var branchRef = new BranchRef()
{
Ref = $"refs/heads/{InputBranchName}",
sha = InputSha
};
var ExpectedJson = JsonConvert.SerializeObject(branchRef);
var fixture = new GitHubFixture();
fixture.SetupCreateBranchWithFailure(ExpectedURL, ExpectedJson);
var repository = new GitHubRepository(fixture.GitHubContext);
var ex = await Assert.ThrowsAsync <RestAPICallException>(async() =>
await repository.CreateBranchAsync(InputOwner, InputRepo, InputBranchName, InputSha)
);
Assert.Equal("InternalServerError", ex.StatusCode);
Assert.Equal("Internal Server Error", ex.Message);
Assert.Equal(ExpectedURL, ex.RequestMessage.RequestUri.ToString());
}
public ReleaseViewModel(
GitHubRepository gitHubRepository,
Release release)
{
GitHubRepository = gitHubRepository;
Release = release;
}
internal static GitHubRepository[] GetRepos(int page, int itemsperpage, int searchKey,
DatabaseConnection connection)
{
//track usage
connection.SearchActions.Add(new SearchAction
{
ActionDescription = "ViewPage " + page,
ActionTime = DateTime.Now,
SearchId = SearchResults[searchKey].DatabaseId
});
connection.SaveChanges();
List <GitHubRepository> result = connection.GitHubRepositories.Where(repo =>
SearchResults[searchKey].ResultSet.Skip(itemsperpage * page).Take(itemsperpage)
.Contains(repo.GitHubRepositoryId)).ToList();
long[] orderingInfo = SearchResults[searchKey].ResultSet.Skip(itemsperpage * page).Take(itemsperpage)
.ToArray();
GitHubRepository[] orderedResult = new GitHubRepository[result.Count];
for (int i = 0; i < result.Count; i++)
{
orderedResult[i] = result.Find(repo => repo.GitHubRepositoryId == orderingInfo[i]);
}
return(orderedResult);
// order the partial result (skip pages, take pagesize) again because the where does not preserve order.
/*
* return OrderItems(connection.GitHubRepositories.Where(repo =>
* SearchResults[searchKey].ResultSet.Skip(itemsperpage * page).Take(itemsperpage)
* .Contains(repo.GitHubRepositoryId)).ToList(), SearchResults[searchKey].Order,
* SearchResults[searchKey].OrderAttribute);
*/
}
public NewAzureDeprecationNotificationV1MessageHandler(GitHubRepository gitHubRepository, IMapper mapper)
{
Guard.NotNull(gitHubRepository, nameof(gitHubRepository));
Guard.NotNull(mapper, nameof(mapper));
_mapper = mapper;
_gitHubRepository = gitHubRepository;
}
public GitHubController(IAppCache cache, GitHubRepository repository, JT7SKUOctoClient octoClient, ILogger <GitHubController> logger, IOptions <GitHubConfiguration> githubConfiguration)
{
this.Cache = cache;
this.Logger = logger;
this.OctoClient = octoClient;
_githubRepository = repository;
_githubConfiguration = githubConfiguration.Value;
}
/// <summary>
/// Initializes the release creator.
/// <para>
/// The target GitHub repository is determined by the remotes of the local
/// repository found in <paramref name="repositoryRootDirectory"/>.
/// </para>
/// </summary>
/// <param name="repositoryRootDirectory">The root directory of the local git repository.</param>
/// <param name="githubToken">A token used for GitHub API authentication.</param>
public Releaser(DirectoryInfo repositoryRootDirectory, string githubToken)
{
using var localRepository = new LocalGitRepository(repositoryRootDirectory.FullName);
_gitHubApi = new GitHubApi(
GitHubRepository.FindByRemotes(localRepository.Remotes),
githubToken);
}
public RepoViewModel(GitHubUser user, GitHubRepository repository, IEnumerable <GitHubCollaborator> collaborators, IIdentity currentUser, IEnumerable <Signature> signers, bool requireCla)
{
User = user;
Repository = repository;
Collaborators = collaborators;
CurrentUser = currentUser;
Signers = signers;
RequireCla = requireCla;
}
/// <summary>
/// Sets up CreateRepositoryAsync.
/// </summary>
private static void SetupCreateRepositoryAsync(
Mock <IGitHubRepositoryClient> repoClient)
{
var repo = new GitHubRepository(1, "GitHubUser", "Project1_LastNameFirstName");
repoClient
.Setup(GetCreateRepositoryExpression())
.ReturnsAsync(repo);
}
public void Url(string remoteUrl, string expectUrl)
{
var gitService = Substitute.For <IGitService>();
var remoteName = "remoteName";
var repo = CreateRepository(remoteName, remoteUrl);
var target = new GitHubRepository(gitService, repo, remoteName);
Assert.That(target.Url, Is.EqualTo(expectUrl));
}
public void AGitJsonPayload_ContainingARepository_WillMapCorrectlyRepositoryStarGazerCount()
{
Prop.ForAll(Generators.JsonGitHubRepository.ToArbitrary(), json =>
{
dynamic user = json;
dynamic expectedNumberOfStarGazers = Convert.ToInt16(user.stargazers_count);
GitHubRepository result = JsonConvert.DeserializeObject <GitHubRepository>(json.ToString());
Assert.AreEqual(expectedNumberOfStarGazers, result.NumberOfStarGazers);
}).QuickCheck();
}
public DefaultRepositoryConfigurator(string username, string password, string repository)
{
Guard.NotNullOrEmpty(username, nameof(username));
Guard.NotNullOrEmpty(password, nameof(password));
Guard.NotNullOrEmpty(repository, nameof(repository));
Repository = repository;
githubRepository = new GitHubRepository(username, password);
}
private Repository Convert(GitHubRepository source)
{
var dest = new Repository();
dest.Name = source.Name;
dest.Size = source.DiskUsage;
dest.Stargazers = source.Stargazers.TotalCount;
dest.Watchers = source.Watchers.TotalCount;
dest.Forks = source.ForkCount;
return(dest);
}
public void AGitJsonPayload_ContainingARepository_WillMapCorrectlyRepositoryUrl()
{
Prop.ForAll(Generators.JsonGitHubRepository.ToArbitrary(), json =>
{
dynamic user = json;
dynamic expectedRepoAddress = user.html_url.ToString();
GitHubRepository result = JsonConvert.DeserializeObject <GitHubRepository>(json.ToString());
Assert.AreEqual(expectedRepoAddress, result.Url);
}).QuickCheck();
}
public void GetPullRequestUrl(string url, int number, string expectUrl)
{
var gitHubRepository = new GitHubRepository {
Url = url
};
var target = new GitPullRequestService();
var pullRequestUrl = target.GetPullRequestUrl(gitHubRepository, number);
Assert.That(pullRequestUrl, Is.EqualTo(expectUrl));
}
/// <summary>
/// Initializes the release notest creator.
/// </summary>
/// <param name="repositoryRootDirectory">The root directory of the local git repository.</param>
/// <param name="githubToken">A token used for GitHub API authentication.</param>
/// <param name="configuration">The configuration to use.</param>
public ReleaseNotesCreator(
DirectoryInfo repositoryRootDirectory,
string githubToken,
ReleaseNotesConfiguration configuration)
{
_localRepository = new LocalGitRepository(repositoryRootDirectory.FullName);
_gitHubRepository = GitHubRepository.FindByRemotes(_localRepository.Remotes);
_gitHubApi = new GitHubApi(_gitHubRepository, githubToken);
_configuration = configuration;
_configuration.EnsureValid();
}
/// <summary>
/// Returns a list of push events for the given project.
/// </summary>
private async Task <StudentRepoPushEvents> GetAllPushEventsAsync(
ClassroomMembership student,
GitHubRepository repository)
{
var pushEvents = await _repoClient.GetPushEventsAsync
(
repository.Owner,
repository.Name
);
return(new StudentRepoPushEvents(student, pushEvents));
}
public void GetUserRepoTest()
{
string gitHubUserName = "******";
string projectName = "busroute";
GitHubApiCalls apiCalls = new GitHubApiCalls();
GitHubRepository repository = apiCalls.GetUserRepo(gitHubUserName, projectName);
if (repository.Id != 24512477)
{
Assert.Fail("O teste falhou pois não retornou o repositório correto!");
}
}
public GitHubController(
IAppCache cache,
GitHubRepository repository,
GithubyMcGithubFaceClient client,
ILogger <GitHubController> logger,
IOptions <GitHubConfiguration> githubConfiguration)
{
this.Cache = cache;
this.Logger = logger;
this.Client = client;
_gitHubRepository = repository;
_gitHubConfiguration = githubConfiguration.Value;
}
private static void TestGitHubOperatorCreateRepository()
{
var serviceProvider = Program.GetServiceProvider();
var gitHubOperator = serviceProvider.GetRequiredService <IGitHubOperator>();
// Create a repository.
var repository = GitHubRepository.GetDefault(Constants.TestingRepositoryName, Constants.TestingRepositoryDescription);
var id = gitHubOperator.CreateRepository(repository).Result;
Console.WriteLine($"Created repository '{repository.Name}' with ID: {id}");
}
private async Task <List <GitHubBranch> > GetBranchData(GitHubRepository repo)
{
string AccessToken = await HttpContext.GetTokenAsync("access_token");
string[] repoData = repo.FullName.Split('/');
List <GitHubBranch> branchList = new List <GitHubBranch>();
var github = new GitHubClient(new ProductHeaderValue("AspNetCoreGitHubAuth"),
new InMemoryCredentialStore(new Credentials(AccessToken)));
IReadOnlyList <Branch> branches = await github.Repository.Branch.GetAll(repoData[0], repoData[1]);
foreach (Branch b in branches)
{
GitHubBranch branch;
lock (thisLock)
{
branch = _context.GitHubBranches.Where(br => br.Name == b.Name).Where(br => br.RepositoryId == repo.RepositoryId).SingleOrDefault();
}
if (branch == null)
{
branch = new GitHubBranch();
branch.Name = b.Name;
branch.RepositoryId = repo.RepositoryId;
branch.Sha = b.Commit.Sha;
branch.ApiUrl = b.Commit.Url;
branch.IsMaster = false;
lock (thisLock)
{
_context.GitHubBranches.Add(branch);
_context.SaveChanges();
}
await GetBranchFiles(repoData[0], repoData[1], branch);
}
else if (branch.Sha != b.Commit.Sha)
{
branch.Sha = b.Commit.Sha;
branch.ApiUrl = b.Commit.Url;
lock (thisLock)
{
_context.GitHubBranches.Add(branch);
_context.SaveChanges();
}
DeleteOldFileData(branch);
await GetBranchFiles(repoData[0], repoData[1], branch);
}
branchList.Add(branch);
}
return(branchList);
}
public async Task Update_FileContents_Normal()
{
var fixture = new GitHubFixture();
fixture.SetUpSampleInputOperation();
var ExpectedURL = $"https://api.github.com/repos/{fixture.InputOwner}/{fixture.InputRepo}/contents/{fixture.InputPath}";
// On the Setup, I call Assert on the Callback.
fixture.SetupUpdateFileContents(ExpectedURL, fixture.InputOperation);
var repository = new GitHubRepository(fixture.GitHubContext);
await repository.UpdateFileContents(fixture.InputOwner, fixture.InputRepo, fixture.InputPath,
fixture.InputOperation);
}
public void Delete_BranchAsync_NormalCase()
{
var InputOwner = "foo";
var InputRepo = "bar";
var InputBranch = "baz";
var ExpectedURL = $"https://api.github.com/repos/{InputOwner}/{InputRepo}/git/refs/heads/{InputBranch}";
var fixture = new GitHubFixture();
fixture.SetUpDeleteAsync(ExpectedURL);
var repository = new GitHubRepository(fixture.GitHubContext);
var result = repository.DeleteBranchAsync(InputOwner, InputRepo, InputBranch);
fixture.VerifyDeleteAsync(ExpectedURL);
}
private async Task <ReleaseViewModel> GetLatestRelease(GitHubRepository gitHubRepository)
{
try
{
var release = await gitHub.GetLatestRelease(gitHubRepository.Owner, gitHubRepository.Name);
return(new ReleaseViewModel(gitHubRepository, release));
}
catch (Exception ex)
{
logger.LogError($"github request failed for {gitHubRepository.Name}", ex);
return(new ReleaseViewModel(gitHubRepository, null));
}
}
/// <summary>
/// Returns collection which contains all repositories of specified used.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public IEnumerable <GitHubRepository> GetRepositories(GitHubUser user)
{
var subs = new List <GitHubRepository>();
JsonParser.ParseCollection(user.ReposUrl + this.ParseUrlArguments(), (token) =>
{
string json = token.ToString();
GitHubRepository repo = new GitHubRepository(json);
subs.Add(repo);
});
return(subs);
}
private static IPullRequestRetriever GetPullRequestRetriever()
{
var client = new Mock<IPullRequestsClient>();
var repository = new GitHubRepository("OlegKleyman", "OctoStyle");
var commits = new List<PullRequestCommit>
{
GetPullRequestCommit("123"),
GetPullRequestCommit("124"),
GetPullRequestCommit("125"),
GetPullRequestCommit(LastCommitId)
};
client.Setup(requestsClient => requestsClient.Commits(repository.Owner, repository.Name, PullRequestNumber))
.ReturnsAsync(commits);
var files = new List<PullRequestFile>
{
GetPullRequestFile(
"321",
RenamedFileName,
"renamed",
RenamedContentUrl,
RenamedChanges),
GetPullRequestFile(
"421",
AddedFileName,
"added",
AddedContentUrl,
AddedChanges),
GetPullRequestFile(
"521",
FirstModifiedFileName,
"modified",
FirstModifiedContentUrl,
FirstModifiedChanges),
GetPullRequestFile(
"621",
SecondModifiedFileName,
"modified",
SecondModifiedContentUrl,
SecondModifiedChanges)
};
client.Setup(requestsClient => requestsClient.Files(repository.Owner, repository.Name, PullRequestNumber))
.ReturnsAsync(files);
var pullRequestUrl =
new Uri(
String.Format(
CultureInfo.InvariantCulture,
"https://api.github.com/repos/{0}/{1}/pulls/{2}",
repository.Owner,
repository.Name,
PullRequestNumber));
client.Setup(requestsClient => requestsClient.Get(repository.Owner, repository.Name, PullRequestNumber))
.ReturnsAsync(
new PullRequest(
pullRequestUrl,
null,
null,
null,
null,
null,
PullRequestNumber,
ItemState.Open,
null,
null,
default(DateTimeOffset),
default(DateTimeOffset),
null,
null,
new GitReference(null, null, PullRequestBranch, null, null, null),
new GitReference(null, null, PullRequestMergeBranch, null, null, null),
null,
null,
true,
null,
null,
0,
0,
0,
0,
0));
var connection = new Mock<IConnection>();
var builder = new Mock<IPullRequestBuilder>();
var mockResponse = new Mock<IResponse>();
connection.Setup(
con =>
con.Get<string>(
It.Is<Uri>(uri => uri.AbsoluteUri == pullRequestUrl.AbsoluteUri),
null,
"application/vnd.github.VERSION.diff"))
.ReturnsAsync(new ApiResponse<string>(mockResponse.Object, FileContents.FullDiff));
var pullRequestFiles = new List<GitHubPullRequestFile>
{
new GitHubPullRequestFile(
RenamedFileName,
GitHubPullRequestFileStatus.Renamed,
RenamedChanges,
FileContents.TestClass2CsDiff),
new GitHubPullRequestFile(
AddedFileName,
GitHubPullRequestFileStatus.Added,
AddedChanges,
FileContents.TestClass3CsDiff),
new GitHubPullRequestFile(
FirstModifiedFileName,
GitHubPullRequestFileStatus.Modified,
FirstModifiedChanges,
FileContents.TestClassCsDiff),
new GitHubPullRequestFile(
SecondModifiedFileName,
GitHubPullRequestFileStatus.Modified,
SecondModifiedChanges,
FileContents.TestLibraryCsprojDiff),
};
var pullRequest = new GitHubPullRequest(
PullRequestNumber,
LastCommitId,
pullRequestFiles,
FileContents.FullDiff,
new GitHubPullRequestBranches(PullRequestBranch, PullRequestMergeBranch));
builder.Setup(
requestBuilder =>
requestBuilder.Build(
PullRequestNumber,
LastCommitId,
files,
FileContents.FullDiff,
It.Is<GitHubPullRequestBranches>(
branches =>
branches.Branch == PullRequestBranch & branches.MergeBranch == PullRequestMergeBranch)))
.Returns(pullRequest);
return new PullRequestRetriever(builder.Object, client.Object, connection.Object, repository);
}
