public override string GetPath()
{
return(String.Format(
"{0}/{1}",
Id.ToLowerInvariant(),
SemanticVersionHelper.Normalize(Version).ToLowerInvariant()));
}
private void SetLatestVersionBranchName(List <VersionInfoViewModel> versions)
{
if (!Project.ExtraProperties.ContainsKey("GithubVersionProviderSource") ||
(GithubVersionProviderSource)(long)Project.ExtraProperties["GithubVersionProviderSource"] == GithubVersionProviderSource.Releases)
{
versions.First(v => !SemanticVersionHelper.IsPreRelease(v.Version)).Version = Project.LatestVersionBranchName;
}
}
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 = SemanticVersionHelper.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 = SemanticVersionHelper.OrderByDescending(versions);
}
}
return(versions);
}
public virtual async Task <IActionResult> OnGetAsync(string keyword)
{
if (!await _documentAppService.FullSearchEnabledAsync())
{
return(RedirectToPage("Index"));
}
KeyWord = keyword;
Project = await _projectAppService.GetAsync(ProjectName);
var output = await _projectAppService.GetVersionsAsync(Project.ShortName);
var versions = output.Items.ToList();
if (versions.Any() &&
string.Equals(Version, DocsAppConsts.Latest, StringComparison.OrdinalIgnoreCase))
{
if ((!Project.ExtraProperties.ContainsKey("GithubVersionProviderSource") ||
(GithubVersionProviderSource)(long)Project.ExtraProperties["GithubVersionProviderSource"] == GithubVersionProviderSource.Releases) &&
!string.IsNullOrEmpty(Project.LatestVersionBranchName))
{
Version = Project.LatestVersionBranchName;
}
else
{
Version = (versions.FirstOrDefault(v => !SemanticVersionHelper.IsPreRelease(v.Name)) ?? versions.First()).Name;
}
}
SearchOutputs = await _documentAppService.SearchAsync(new DocumentSearchInput
{
ProjectId = Project.Id,
Context = KeyWord,
LanguageCode = LanguageCode,
Version = Version
});
var highlightTag1 = Guid.NewGuid().ToString();
var highlightTag2 = Guid.NewGuid().ToString();
foreach (var searchOutput in SearchOutputs)
{
for (var i = 0; i < searchOutput.Highlight.Count; i++)
{
searchOutput.Highlight[i] = _encoder
.Encode(searchOutput.Highlight[i].Replace("<highlight>", highlightTag1)
.Replace("</highlight>", highlightTag2))
.Replace(highlightTag1, "<highlight>").Replace(highlightTag2, "</highlight>");
}
}
return(Page());
}
private VersionInfoViewModel GetLatestVersionInfo(List <VersionInfoViewModel> versions)
{
if (Project.ExtraProperties.ContainsKey("GithubVersionProviderSource") &&
(GithubVersionProviderSource)(long)Project.ExtraProperties["GithubVersionProviderSource"] == GithubVersionProviderSource.Branches)
{
var LatestVersionBranchNameWithoutPrefix = RemoveVersionPrefix(Project.LatestVersionBranchName);
foreach (var version in versions)
{
if (version.Version == LatestVersionBranchNameWithoutPrefix)
{
return(version);
}
version.DisplayText = $"{version.DisplayText} ({L["Preview"].Value})";
version.IsPreview = true;
}
}
return(versions.FirstOrDefault(v => !SemanticVersionHelper.IsPreRelease(v.Version)) ?? versions.First());
}
private string GetKey(string id, string version)
{
return((id + "/" + SemanticVersionHelper.Normalize(version)).ToLower());
}
private async Task DeleteP(List <PackageConfigParser.Package> IdAndVersion)
{
var dc = GetDatacenter(0, required: false);
if (dc != null)
{
var defaults = await LoadDefaultsFromAzure(dc, DatabaseConnectionString, StorageConnectionString);
DatabaseConnectionString = defaults.DatabaseConnectionString;
StorageConnectionString = defaults.StorageConnectionString;
}
StorageAccount = CloudStorageAccount.Parse(StorageConnectionString);
// Connect to the database
using (var conn = new SqlConnection(DatabaseConnectionString))
{
await conn.OpenAsync();
foreach (PackageConfigParser.Package pkg in IdAndVersion)
{
Id = pkg.Id;
Version = pkg.Version;
// Parse the version
if (!String.IsNullOrWhiteSpace(Version))
{
Version = SemanticVersionHelper.Normalize(Version);
}
var packages = conn.Query(@"
SELECT
p.[Key],
p.PackageRegistrationKey,
pr.Id,
p.NormalizedVersion AS Version,
p.Hash
FROM Packages p
INNER JOIN PackageRegistrations pr ON p.PackageRegistrationKey = pr.[Key]
WHERE pr.Id = @Id AND (@AllVersions = 1 OR p.NormalizedVersion = @Version)", new
{
Id,
AllVersions,
Version
});
await Console.WriteInfoLine(Strings.Package_DeleteCommand_DeleteList_Header, (dc == null ? "<unknown>" : dc.FullName));
foreach (var package in packages)
{
await Console.WriteInfoLine(
Strings.Package_DeleteCommand_DeleteList_Item,
(string)package.Id,
(string)package.Version);
}
// Ask the user to confirm by typing the ID
if (!WhatIf && !Quiet)
{
await Console.WriteInfoLine(Strings.Package_DeleteCommand_NonWhatIf);
string typed = await Console.Prompt(Strings.Package_DeleteCommand_DeleteList_Confirm);
if (!String.Equals(typed, Id, StringComparison.Ordinal))
{
await Console.WriteErrorLine(Strings.Package_DeleteCommand_IncorrectId, typed);
return;
}
}
foreach (var package in packages)
{
await DeletePackage(package, conn);
}
if (AllVersions)
{
await DeleteRegistration(conn);
}
}
}
}
protected override async Task OnExecute()
{
if (String.IsNullOrWhiteSpace(Version) && !All)
{
await Console.WriteErrorLine(Strings.Package_AllVersionsRequiredIfVersionNull);
return;
}
// Get Datacenter 0
var dc = GetDatacenter(0, required: false);
if (dc != null)
{
var defaults = await LoadDefaultsFromAzure(dc, DatabaseConnectionString, StorageConnectionString);
DatabaseConnectionString = defaults.DatabaseConnectionString;
StorageConnectionString = defaults.StorageConnectionString;
}
StorageAccount = CloudStorageAccount.Parse(StorageConnectionString);
// Parse the version
if (!String.IsNullOrWhiteSpace(Version))
{
Version = SemanticVersionHelper.Normalize(Version);
}
if (!String.IsNullOrWhiteSpace(Version) && All)
{
await Console.WriteErrorLine(Strings.Package_VersionAndAllVersionsSpecified);
return;
}
IEnumerable <dynamic> packages;
int totalCount;
// Get all of the packages to be processed
using (var conn = new SqlConnection(DatabaseConnectionString))
{
await conn.OpenAsync();
var sql = Unsupported ? SqlUnsupportedPackages : SqlAllPackages;
await Console.WriteInfoLine("Getting the list of packages to process from SQL.{0}", Unsupported? " Filtering to those containing an 'Unsupported' framework." : "");
packages = conn.Query(sql, new
{
Id,
All,
Version
});
totalCount = packages.Count();
await Console.WriteInfoLine("Found {0} package(s) to process", totalCount);
}
if (!WhatIf)
{
bool confirmed = await Console.Confirm(
String.Format(
Strings.Package_PopulatePackageFrameworksCommand_Confirm,
packages.Count(),
(dc == null ? "<unknown>" : dc.FullName)),
defaultValue : true);
if (!confirmed)
{
await Console.WriteErrorLine(Strings.SystemConsole_ConfirmDenied);
return;
}
}
int processedCount = 0;
packages
.AsParallel()
.AsOrdered()
// Use 2 threads per processor, because we might find ourselves
// waiting on SQL
.WithDegreeOfParallelism(System.Environment.ProcessorCount * 2)
.ForAll(package =>
{
var thisPackageId = Interlocked.Increment(ref processedCount);
ProcessPackage(package, thisPackageId, totalCount);
});
}
