public async Task <List <VersionInfo> > GetVersionsAsync(Project project)
{
List <VersionInfo> versions;
try
{
versions = (await GetReleasesAsync(project))
.OrderByDescending(r => r.PublishedAt)
.Select(r => new VersionInfo
{
Name = r.TagName,
DisplayName = r.TagName
}).ToList();
}
catch (Exception ex)
{
//TODO: It may not be a good idea to hide the error!
Logger.LogError(ex.Message, ex);
versions = new List <VersionInfo>();
}
if (!versions.Any() && !string.IsNullOrEmpty(project.LatestVersionBranchName))
{
versions.Add(new VersionInfo {
DisplayName = "1.0.0", Name = project.LatestVersionBranchName
});
}
return(versions);
}
private async Task <DateTime?> GetLastSignificantUpdateTime(
IReadOnlyList <GitHubCommit> commits,
Project project,
string fileName,
DateTime?lastKnownSignificantUpdateTime,
DateTime documentCreationTime)
{
if (commits == null || !commits.Any())
{
return(null);
}
var fileCommitsAfterCreation = commits.Take(commits.Count - 1);
var commitsToEvaluate = (lastKnownSignificantUpdateTime != null
? fileCommitsAfterCreation.Where(c => c.Commit.Author.Date.DateTime > lastKnownSignificantUpdateTime)
: fileCommitsAfterCreation).Where(c => c.Commit.Author.Date.DateTime > DateTime.Now.AddDays(-14));
foreach (var gitHubCommit in commitsToEvaluate)
{
var fullCommit = await _githubRepositoryManager.GetSingleCommitsAsync(
GetOwnerNameFromUrl(project.GetGitHubUrl()),
GetRepositoryNameFromUrl(project.GetGitHubUrl()),
gitHubCommit.Sha,
project.GetGitHubAccessTokenOrNull());
if (_githubPatchAnalyzer.HasPatchSignificantChanges(fullCommit.Files.First(f => f.Filename == fileName).Patch))
{
return(gitHubCommit.Commit.Author.Date.DateTime);
}
}
return(null);
}
public virtual async Task <Document> GetDocument(Project project, string documentName, string version)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var rawRootUrl = CalculateRawRootUrl(rootUrl);
var rawDocumentUrl = rawRootUrl + documentName;
var commitHistoryUrl = project.GetGitHubUrlForCommitHistory() + documentName;
var editLink = rootUrl.ReplaceFirst("/tree/", "/blob/") + documentName;
var localDirectory = "";
var fileName = documentName;
if (documentName.Contains("/"))
{
localDirectory = documentName.Substring(0, documentName.LastIndexOf('/'));
fileName = documentName.Substring(documentName.LastIndexOf('/') + 1);
}
return(new Document
{
Title = documentName,
EditLink = editLink,
RootUrl = rootUrl,
RawRootUrl = rawRootUrl,
Format = project.Format,
LocalDirectory = localDirectory,
FileName = fileName,
Contributors = await GetContributors(commitHistoryUrl, token),
Version = version,
Content = await DownloadWebContentAsStringAsync(rawDocumentUrl, token)
});
}
public virtual async Task <Document> GetDocumentAsync(Project project, string documentName, string languageCode, string version)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var userAgent = project.GetGithubUserAgentOrNull();
var rawRootUrl = CalculateRawRootUrlWithLanguageCode(rootUrl, languageCode);
var rawDocumentUrl = rawRootUrl + documentName;
var commitHistoryUrl = project.GetGitHubUrlForCommitHistory() + documentName;
var isNavigationDocument = documentName == project.NavigationDocumentName;
var isParameterDocument = documentName == project.ParametersDocumentName;
var editLink = rootUrl.ReplaceFirst("/tree/", "/blob/") + languageCode + "/" + documentName;
var localDirectory = "";
var fileName = documentName;
if (documentName.Contains("/"))
{
localDirectory = documentName.Substring(0, documentName.LastIndexOf('/'));
fileName = documentName.Substring(documentName.LastIndexOf('/') + 1);
}
return(new Document
{
Title = documentName,
EditLink = editLink,
RootUrl = rootUrl,
RawRootUrl = rawRootUrl,
Format = project.Format,
LocalDirectory = localDirectory,
FileName = fileName,
Contributors = new List <DocumentContributor>(),
//Contributors = !isNavigationDocument && !isParameterDocument ? await GetContributors(commitHistoryUrl, token, userAgent): new List<DocumentContributor>(),
Version = version,
Content = await DownloadWebContentAsStringAsync(rawDocumentUrl, token, userAgent)
});
}
private async Task <IReadOnlyList <Release> > GetReleasesAsync(Project project)
{
var url = project.GetGitHubUrl();
var ownerName = GetOwnerNameFromUrl(url);
var repositoryName = GetRepositoryNameFromUrl(url);
return(await _githubRepositoryManager.GetReleasesAsync(ownerName, repositoryName, project.GetGitHubAccessTokenOrNull()));
}
public async Task <List <VersionInfo> > GetVersionsAsync(Project project)
{
var url = project.GetGitHubUrl();
var ownerName = GetOwnerNameFromUrl(url);
var repositoryName = GetRepositoryNameFromUrl(url);
var githubVersionProviderSource = GetGithubVersionProviderSource(project);
List <VersionInfo> versions;
try
{
versions = (await _githubRepositoryManager.GetVersionsAsync(ownerName, repositoryName, project.GetGitHubAccessTokenOrNull(), githubVersionProviderSource))
.Select(r => new VersionInfo
{
Name = r.Name,
DisplayName = r.Name
}).ToList();
}
catch (Exception ex)
{
//TODO: It may not be a good idea to hide the error!
Logger.LogError(ex.Message, ex);
versions = new List <VersionInfo>();
}
if (githubVersionProviderSource == GithubVersionProviderSource.Branches && project.ExtraProperties.ContainsKey("VersionBranchPrefix"))
{
var prefix = (string)project.ExtraProperties["VersionBranchPrefix"];
if (!string.IsNullOrEmpty(prefix))
{
versions = versions.Where(v => v.Name.StartsWith(prefix)).ToList();
foreach (var v in versions)
{
v.Name = v.Name.Substring(prefix.Length);
v.DisplayName = v.DisplayName.Substring(prefix.Length);
}
}
versions = _versionHelper.OrderByDescending(versions);
}
if (githubVersionProviderSource == GithubVersionProviderSource.Releases)
{
if (!versions.Any() && !string.IsNullOrEmpty(project.LatestVersionBranchName))
{
versions.Add(new VersionInfo {
DisplayName = "1.0.0", Name = project.LatestVersionBranchName
});
}
else
{
versions = _versionHelper.OrderByDescending(versions);
}
}
return(versions);
}
private async Task <IReadOnlyList <GitHubCommit> > GetFileCommitsAsync(Project project, string version, string filename)
{
var url = project.GetGitHubUrl();
var ownerName = GetOwnerNameFromUrl(url);
var repositoryName = GetRepositoryNameFromUrl(url);
return(await _githubRepositoryManager.GetFileCommitsAsync(ownerName, repositoryName,
version, filename, project.GetGitHubAccessTokenOrNull()));
}
public async Task <DocumentResource> GetResource(Project project, string resourceName, string version)
{
var rawRootUrl = CalculateRawRootUrl(project.GetGitHubUrl(version));
var content = await DownloadWebContentAsByteArrayAsync(
rawRootUrl + resourceName,
project.GetGitHubAccessTokenOrNull()
);
return(new DocumentResource(content));
}
public virtual async Task <Document> GetDocumentAsync(Project project, string documentName, string languageCode, string version)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var userAgent = project.GetGithubUserAgentOrNull();
var rawRootUrl = CalculateRawRootUrlWithLanguageCode(rootUrl, languageCode);
var rawDocumentUrl = rawRootUrl + documentName;
var isNavigationDocument = documentName == project.NavigationDocumentName;
var isParameterDocument = documentName == project.ParametersDocumentName;
var editLink = rootUrl.ReplaceFirst("/tree/", "/blob/") + languageCode + "/" + documentName;
var localDirectory = "";
var fileName = documentName;
if (documentName.Contains("/"))
{
localDirectory = documentName.Substring(0, documentName.LastIndexOf('/'));
fileName = documentName.Substring(documentName.LastIndexOf('/') + 1);
}
var fileCommits = await GetFileCommitsAsync(project, version, $"docs/{languageCode}/{documentName}");
var document = new Document(GuidGenerator.Create(),
project.Id,
documentName,
version,
languageCode,
fileName,
await DownloadWebContentAsStringAsync(rawDocumentUrl, token, userAgent),
project.Format,
editLink,
rootUrl,
rawRootUrl,
localDirectory,
fileCommits.LastOrDefault()?.Commit.Author.Date.DateTime ?? DateTime.MinValue,
fileCommits.FirstOrDefault()?.Commit.Author.Date.DateTime ?? DateTime.MinValue,
DateTime.Now);
var authors = fileCommits
.Where(x => x.Author != null)
.Select(x => x.Author)
.GroupBy(x => x.Id)
.OrderByDescending(x => x.Count())
.Select(x => x.FirstOrDefault()).ToList();
if (!isNavigationDocument && !isParameterDocument)
{
foreach (var author in authors)
{
document.AddContributor(author.Login, author.HtmlUrl, author.AvatarUrl);
}
}
return(document);
}
private async Task <IReadOnlyList <Release> > GetReleasesAsync(Project project)
{
var url = project.GetGitHubUrl();
var ownerName = GetOwnerNameFromUrl(url);
var repositoryName = GetRepositoryNameFromUrl(url);
var gitHubClient = CreateGitHubClient(project.GetGitHubAccessTokenOrNull());
return(await gitHubClient
.Repository
.Release
.GetAll(ownerName, repositoryName));
}
public async Task <LanguageConfig> GetLanguageListAsync(Project project, string version)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var userAgent = project.GetGithubUserAgentOrNull();
var url = CalculateRawRootUrl(rootUrl) + "docs-langs.json";
var configAsJson = await DownloadWebContentAsStringAsync(url, token, userAgent);
return(JsonConvert.DeserializeObject <LanguageConfig>(configAsJson));
}
public async Task <LanguageConfig> GetLanguageListAsync(Project project, string version)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var userAgent = project.GetGithubUserAgentOrNull();
var url = CalculateRawRootUrl(rootUrl) + DocsDomainConsts.LanguageConfigFileName;
var configAsJson = await DownloadWebContentAsStringAsync(url, token, userAgent);
if (!JsonConvertExtensions.TryDeserializeObject <LanguageConfig>(configAsJson, out var languageConfig))
{
throw new UserFriendlyException($"Cannot validate language config file '{DocsDomainConsts.LanguageConfigFileName}' for the project {project.Name} - v{version}.");
}
return(languageConfig);
}
private async Task <IReadOnlyList <GitHubCommit> > GetGitHubCommitsOrNull(Project project, string documentName, string languageCode, string version)
{
/*
* Getting file commits usually throws "Resource temporarily unavailable" or "Network is unreachable"
* This is a trival information and running this inside try-catch is safer.
*/
try
{
return(await GetFileCommitsAsync(project, version, project.GetGitHubInnerUrl(languageCode, documentName)));
}
catch (Exception e)
{
Logger.LogError(e.ToString());
return(null);
}
}
public async Task <List <VersionInfo> > GetVersions(Project project)
{
try
{
return((await GetReleasesAsync(project))
.OrderByDescending(r => r.PublishedAt)
.Select(r => new VersionInfo
{
Name = r.TagName,
DisplayName = r.TagName
}).ToList());
}
catch (Exception ex)
{
//TODO: It may not be a good idea to hide the error!
Logger.LogError(ex.Message, ex);
return(new List <VersionInfo>());
}
}
private async Task <DateTime?> GetLastKnownSignificantUpdateTime(
Project project,
string documentName,
string languageCode,
string version,
DateTime?lastKnownSignificantUpdateTime,
bool isNavigationDocument,
bool isParameterDocument,
IReadOnlyList <GitHubCommit> commits,
DateTime documentCreationTime)
{
return(!isNavigationDocument && !isParameterDocument && version == project.LatestVersionBranchName
? await GetLastSignificantUpdateTime(
commits,
project,
project.GetGitHubInnerUrl(languageCode, documentName),
lastKnownSignificantUpdateTime,
documentCreationTime
) ?? lastKnownSignificantUpdateTime
: null);
}
public virtual async Task <Document> GetDocumentAsync(Project project, string documentName, string languageCode, string version, DateTime?lastKnownSignificantUpdateTime = null)
{
var token = project.GetGitHubAccessTokenOrNull();
var rootUrl = project.GetGitHubUrl(version);
var userAgent = project.GetGithubUserAgentOrNull();
var rawRootUrl = CalculateRawRootUrlWithLanguageCode(rootUrl, languageCode);
var rawDocumentUrl = rawRootUrl + documentName;
var isNavigationDocument = documentName == project.NavigationDocumentName;
var isParameterDocument = documentName == project.ParametersDocumentName;
var editLink = rootUrl.ReplaceFirst("/tree/", "/blob/").EnsureEndsWith('/') + languageCode + "/" + documentName;
var localDirectory = "";
var fileName = documentName;
if (documentName.Contains("/"))
{
localDirectory = documentName.Substring(0, documentName.LastIndexOf('/'));
fileName = documentName.Substring(documentName.LastIndexOf('/') + 1);
}
var content = await DownloadWebContentAsStringAsync(rawDocumentUrl, token, userAgent);
var commits = await GetGitHubCommitsOrNull(project, documentName, languageCode, version);
var documentCreationTime = GetFirstCommitDate(commits);
var lastUpdateTime = GetLastCommitDate(commits);
var lastSignificantUpdateTime = await GetLastKnownSignificantUpdateTime(project, documentName, languageCode, version, lastKnownSignificantUpdateTime, isNavigationDocument, isParameterDocument, commits, documentCreationTime);
var document = new Document
(
GuidGenerator.Create(),
project.Id,
documentName,
version,
languageCode,
fileName,
content,
project.Format,
editLink,
rootUrl,
rawRootUrl,
localDirectory,
documentCreationTime,
lastUpdateTime,
DateTime.Now,
lastSignificantUpdateTime
);
if (isNavigationDocument || isParameterDocument)
{
return(document);
}
var authors = GetAuthors(commits);
foreach (var author in authors)
{
document.AddContributor(author.Login, author.HtmlUrl, author.AvatarUrl);
}
return(document);
}
private GithubVersionProviderSource GetGithubVersionProviderSource(Project project)
{
return(project.ExtraProperties.ContainsKey("GithubVersionProviderSource")
? (GithubVersionProviderSource)(long)project.ExtraProperties["GithubVersionProviderSource"]
: GithubVersionProviderSource.Releases);
}
