public void SetFilepath(string filename)
{
string filepath = Path.Combine(_webRoot, filename);
Filepath = filepath;
TemplatePacks = TemplatePack.CreateFromFile(filepath);
}
public async void ExecuteNavigateToTemplatePack()
{
var helper = new TemplateHelper();
TemplatePack pack = helper.GetTemplatePackById(Template.TemplatePackId, helper.GetTemplatePacks());
await Navigation.PushAsync(new TemplatePackPage( new TemplatePackViewModel(pack, Navigation)));
}
public void TestCreateFromFile()
{
string filepath = GetTestFilepath(@"template-report01.json");
List <TemplatePack> result = TemplatePack.CreateFromFile(filepath);
Assert.NotNull(result);
Assert.True(result.Count > 0);
}
public void TestCreateTemplateFromJson()
{
string templateJsonPath = Path.Combine(sampleFileHelper.GetSamplesFolder(), "templatejson", "template01.json");
var result = TemplatePack.CreateTemplateFromJsonFile(templateJsonPath, "test-case");
Assert.NotNull(result);
Assert.True(!string.IsNullOrEmpty(result.Identity));
Assert.NotNull(result.Tags);
}
public async Task OnGetAsync(string packId)
{
if (string.IsNullOrWhiteSpace(packId))
{
return;
}
PackId = packId;
TemplatePack = await GetFromApiAsync <TemplatePack>($"templatepack/{PackId}");
}
public void OnGet(string packId)
{
if (string.IsNullOrWhiteSpace(packId))
{
return;
}
PackId = packId;
TemplatePack = GetFromApi <TemplatePack>($"templatepack/{PackId}");
}
public TemplatePackViewModel(TemplatePack pack, INavigation navigation)
{
Pack = pack;
Navigation = navigation;
BrowseToNuGet = new Command(ExecuteBrowseToNuget);
BrowseProjectSite = new Command(ExecuteBrowseProjectSite);
BrowseLicense = new Command(ExecuteBrowseToLicense);
ShareCommand = new Command(ExecuteShare);
ShowActions = new Command(() => ExecuteShowActions());
SearchAuthor = new Command(() => ExecuteSearchAuthor());
}
public TemplatePack GetTemplatePackById(string package, List <TemplatePack> packs)
{
TemplatePack pack = null;
foreach (var p in packs)
{
if (string.Compare(package, p.Package, StringComparison.OrdinalIgnoreCase) == 0)
{
pack = p;
break;
}
}
return(pack);
}
private void InitFrom(TemplatePack tp)
{
Debug.Assert(tp != null);
var extractFolderPath = Path.Combine(_cacheFolderPath, "extracted", Normalize($"{tp.Package}.{tp.Version}.nupkg"));
if (!Directory.Exists(extractFolderPath))
{
throw new DirectoryNotFoundException($"directory not found at {extractFolderPath}");
}
PackageName = tp.Package;
Version = tp.Version;
HasLibFolder = Directory.Exists(Path.Combine(extractFolderPath, "lib"));
// read the nuspec file to get the package type
var nuspecFilePath = Path.Combine(extractFolderPath, Normalize($"{tp.Package}.nuspec"));
if (!File.Exists(nuspecFilePath))
{
throw new FileNotFoundException($"nuspec file not found at {nuspecFilePath}");
}
XDocument xmldoc = XDocument.Parse(File.ReadAllText(nuspecFilePath));
var f = xmldoc.Root.Descendants("package");
var result = xmldoc.Root.Attributes().
Where(a => a.IsNamespaceDeclaration && string.Compare("xmlns", a.Name.LocalName) == 0).
First().Value;
var packageType = (from e in xmldoc.Descendants()
where e.Name.Namespace == result
where e.Name.LocalName == "packageType"
select e.Attribute("name").Value).ToList();
packageType.Sort();
PackageType = packageType;
DownloadCount = tp.DownloadCount;
}
private void CreateTemplatePackFile(List <TemplatePack> templatePacks, string templateReportJsonPath, string resultsPath)
{
// write the results to a temp file, and then copy to the final destination
var tempfilepath = Path.GetTempFileName();
//var templatePacks = TemplatePack.CreateFromFile(templateReportJsonPath);
using var writer = new StreamWriter(tempfilepath);
writer.WriteLine("package name, version, has lib folder, packagetype,num-downloads");
foreach (var tp in templatePacks)
{
var info = new TemplatePackReportInternalSummaryInfo(_remoteFile.CacheFolderpath, tp);
var line = GetTemplatePackReportLineFor(info);
Console.WriteLine(line);
writer.WriteLine(line);
}
writer.Flush();
writer.Close();
// string resultsPath = optionAnalysisResultFilePath.HasValue() ? optionAnalysisResultFilePath.Value() : "template-pack-analysis.csv";
Console.WriteLine($"writing analysis file to {resultsPath}");
File.Copy(tempfilepath, resultsPath, true);
// now create the template-details.csv file
var allTemplates = new List <Template>();
var allTemplateInfos = new List <TemplateReportSummaryInfo>();
foreach (var tp in templatePacks)
{
var extractFolderPath = Path.Combine(_remoteFile.CacheFolderpath, "extracted", ($"{tp.Package}.{tp.Version}.nupkg").ToLowerInvariant());
var templates = TemplatePack.GetTemplateFilesUnder(extractFolderPath);
foreach (var template in templates)
{
var templateObj = Template.CreateFromFile(template);
allTemplates.Add(templateObj);
allTemplateInfos.Add(new TemplateReportSummaryInfo {
Template = templateObj
});
}
}
}
public override Command CreateCommand() =>
new Command(name: "search", description: "search for templates")
{
CommandHandler.Create <string>(async(searchTerm) => {
var previousTemplateReportPath = _reportLocator.GetTemplateReportJsonPath();
_reporter.WriteVerboseLine($"loading previous template-report.json from '{previousTemplateReportPath}'");
var templatePacks = TemplatePack.CreateFromFile(previousTemplateReportPath);
_reporter.WriteVerboseLine($"Num template packs in previous report: '{templatePacks.Count}'");
var result = _searcher.Search(searchTerm, templatePacks);
List <UserOption> options = new List <UserOption>();
foreach (var template in result)
{
options.Add(new UserOption($"{template.Name} - ({template.TemplatePackId})", template));
}
var consoleWrapper = new DirectConsoleWrapper();
PickManyPrompt pmp = new PickManyPrompt("Select templates to install (↑↓ to navigate, Space to select, and Enter to commit)", options);
bool doSharprompt = true;
IPromptInvoker pi;
pi = doSharprompt ? (IPromptInvoker) new SharPromptInvoker() : new PromptInvoker(consoleWrapper);
var promptResult = pi.GetPromptResult(pmp) as PickManyPrompt;
var templatesToInstall = promptResult.UserOptions
.Where(uo => uo.IsSelected)
.Select(uo => uo.Value as Template);
if (templatesToInstall == null)
{
_reporter.WriteLine("noting selected to install");
return;
}
var templateInstallList = templatesToInstall.ToList();
await InstallTemplatesAsync(templateInstallList);
}),
ArgSearchTerm()
};
public TemplatePackReportInternalSummaryInfo(string cacheFolderPath, TemplatePack tp)
{
_cacheFolderPath = cacheFolderPath;
InitFrom(tp);
}
public override void Setup(CommandLineApplication command)
{
base.Setup(command);
var optionTemplateReportJsonPath = command.Option <string>(
"-trp|--templateReportPath",
"the path to the template-report.json file",
CommandOptionType.SingleValue);
optionTemplateReportJsonPath.IsRequired();
//var optionAnalysisResultFilePath = command.Option<string>(
// "-arp|--analysisResultPath",
// "path to where the results will be written to",
// CommandOptionType.SingleValue);
var optionOutputDir = command.Option <string>(
"-od|--output-dir",
"folder path where files will be written",
CommandOptionType.SingleValue);
OnExecute = () => {
EnableVerboseOption = OptionVerbose.HasValue();
var templateReportJsonPath = optionTemplateReportJsonPath.Value();
if (!File.Exists(templateReportJsonPath))
{
throw new FileNotFoundException($"template-report.json file not found at {templateReportJsonPath}");
}
var templatePacks = TemplatePack.CreateFromFile(templateReportJsonPath);
List <string> createdFiles = new List <string>();
string outdir = optionOutputDir.HasValue() ? optionOutputDir.Value() : Directory.GetCurrentDirectory();
string templatePackFile = Path.Combine(outdir, "template-pack-analysis.csv");
CreateTemplatePackFile(templatePacks, templateReportJsonPath, templatePackFile);
createdFiles.Add(templatePackFile);
// create the json file that contains all the templates
var allTemplates = new List <Template>();
var allTemplateInfos = new List <TemplateReportSummaryInfo>();
var allHostFiles = new List <TemplateHostFile>();
foreach (var tp in templatePacks)
{
var extractFolderPath = Path.Combine(_remoteFile.CacheFolderpath, "extracted", ($"{tp.Package}.{tp.Version}.nupkg").ToLowerInvariant());
// populate the HostFiles property of the template pack
var templates = TemplatePack.GetTemplateFilesUnder(extractFolderPath);
foreach (var template in templates)
{
var templateObj = Template.CreateFromFile(template);
templateObj.TemplatePackId = tp.Package;
templateObj.InitHostFilesFrom(Path.GetDirectoryName(template), templateObj.TemplatePackId, templateObj.Name);
allTemplates.Add(templateObj);
allTemplateInfos.Add(new TemplateReportSummaryInfo {
Template = templateObj
});
if (templateObj.HostFiles != null && templateObj.HostFiles.Count > 0)
{
allHostFiles.AddRange(templateObj.HostFiles);
}
}
}
var allTemplatesJsonPath = Path.Combine(outdir, "template-all.json");
CreateAllTemplatesJsonFile(allTemplates, allTemplatesJsonPath);
createdFiles.Add(allTemplatesJsonPath);
// create the template-details.csv file now
var templateDetailsCsvPath = Path.Combine(outdir, "template-details.csv");
CreateTemplateDetailsCsvFile(allTemplateInfos, templateDetailsCsvPath);
createdFiles.Add(templateDetailsCsvPath);
var hostFileDetailsCsvPath = Path.Combine(outdir, "template-host-files.csv");
CreateHostFilesDetailsCsvFile(allHostFiles, hostFileDetailsCsvPath);
createdFiles.Add(hostFileDetailsCsvPath);
Console.WriteLine("Created files:");
foreach (var cf in createdFiles)
{
Console.WriteLine($" {cf}");
}
return(1);
};
}
private void CreateTemplatePackFile(List <TemplatePack> templatePacks, string templateReportJsonPath, string resultsPath)
{
// write the results to a temp file, and then copy to the final destination
var tempfilepath = Path.GetTempFileName();
//var templatePacks = TemplatePack.CreateFromFile(templateReportJsonPath);
using var writer = new StreamWriter(tempfilepath);
writer.WriteLine("package name, version, has lib folder, packagetype,num-downloads");
// list of template packs that could not be initalized for some reason
// they need to be removed from the list to prevent futher issues
var tpToRemove = new List <TemplatePack>();
foreach (var tp in templatePacks)
{
TemplatePackReportInternalSummaryInfo info = null;
try {
info = new TemplatePackReportInternalSummaryInfo(_remoteFile.CacheFolderpath, tp);
}
catch (TemplateInitException tie) {
// TODO: Reporter should be used instead of writing directly to the console
Console.WriteLine($"ERROR: Unable to initalize template pack from '{tp.Package}', skipping this one. Error: {tie.ToString()}");
tpToRemove.Add(tp);
continue;
}
var line = GetTemplatePackReportLineFor(info);
Console.WriteLine(line);
writer.WriteLine(line);
}
writer.Flush();
writer.Close();
if (tpToRemove.Count > 0)
{
foreach (var tp in tpToRemove)
{
templatePacks.Remove(tp);
}
}
// string resultsPath = optionAnalysisResultFilePath.HasValue() ? optionAnalysisResultFilePath.Value() : "template-pack-analysis.csv";
var dir = Path.GetDirectoryName(resultsPath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
Console.WriteLine($"writing analysis file to {resultsPath}");
File.Copy(tempfilepath, resultsPath, true);
// now create the template-details.csv file
var allTemplates = new List <Template>();
var allTemplateInfos = new List <TemplateReportSummaryInfo>();
foreach (var tp in templatePacks)
{
var extractFolderPath = Path.Combine(_remoteFile.CacheFolderpath, "extracted", ($"{tp.Package}.{tp.Version}.nupkg").ToLowerInvariant());
var templates = TemplatePack.GetTemplateFilesUnder(extractFolderPath);
foreach (var template in templates)
{
// TODO: null check is needed here
var templateObj = Template.CreateFromFile(template);
if (templateObj != null)
{
allTemplates.Add(templateObj);
allTemplateInfos.Add(new TemplateReportSummaryInfo {
Template = templateObj
});
}
else
{
Console.WriteLine($"unable to initalize template from path '{template.ToString()}'");
}
}
}
}
public List <TemplatePack> GetTemplatePacks()
{
var text = GetTemplateJsonFileContents();
return(TemplatePack.CreateFromText(text));
}
public string GetIconUrlFor(TemplatePack templatePack) => string.IsNullOrEmpty(templatePack?.IconUrl) ? Strings.DefaultTemplatePackIconUrl : templatePack?.IconUrl;
public override void Setup(CommandLineApplication command)
{
base.Setup(command);
var optionTemplateReportFilepath = command.Option <string>(
"-trf|--template-report-file",
"path to the template-report.json file",
CommandOptionType.SingleValue);
var optionCsvOutputPath = command.Option <string>(
"-cop|--csv-output-path",
"output path for the csv file, default is to create the file in the current directory",
CommandOptionType.SingleValue);
var optionTemplateCacheFilepath = command.Option <string>(
"-tcf|--template-cache-file",
"path to the templatecache.json this is ususally typically found in subfolders under %HOMEPATH%/.templateengine/dotnetcli",
CommandOptionType.SingleValue);
OnExecute = () => {
var reportFilepath = optionTemplateReportFilepath.HasValue() ?
optionTemplateReportFilepath.Value() :
null;
if (string.IsNullOrEmpty(reportFilepath))
{
throw new ArgumentNullException("template-report-file parameter missing");
}
var destPath = optionCsvOutputPath.HasValue() ?
optionCsvOutputPath.Value() :
Path.Combine(Directory.GetCurrentDirectory(), $"template-result.{DateTime.Now.ToString("MM.dd.yy-H.m.s.ffff")}.csv");
var destFile = destPath;
if (!Path.HasExtension(destFile))
{
destFile = Path.Combine(destFile, $"template-result.{DateTime.Now.ToString("MM.dd.yy-H.m.s.ffff")}.csv");
}
//var destFile = Path.Combine(Directory.GetCurrentDirectory(), $"template-result.{DateTime.Now.ToString("MM.dd.yy-H.m.s.ffff")}.csv");
Console.WriteLine($"destFile: {destFile}");
var sb = new StringBuilder();
// var destFile =
// load the json file
var templatePack = TemplatePack.CreateFromFile(reportFilepath);
sb.AppendLine("Identity,hash,hashLower,idhash,idhashLower,groupidhash,groupidHashLower,clihash,cliUpperHash,cliLowerHash");
foreach (var tp in templatePack)
{
foreach (var template in tp.Templates)
{
var hashInfo = new TemplateHashInfo {
GroupIdentity = template.GroupIdentity,
Identity = template.Identity,
Language = template.GetLanguage()
};
var hash = TemplateHashExtensions.EncodeAndGenerateHash(hashInfo);
var hashLower = TemplateHashExtensions.EncodeAndGenerateHash(hashInfo, true);
var idhash = TemplateHashExtensions.GenerateHash(template.Identity);
var idhashLower = TemplateHashExtensions.GenerateHash(template.Identity != null? template.Identity.ToLowerInvariant():string.Empty);
var groupIdHash = TemplateHashExtensions.GenerateHash(template.GroupIdentity);
var groupIdHashLower = TemplateHashExtensions.GenerateHash(template.GroupIdentity != null ? template.GroupIdentity.ToLowerInvariant() : string.Empty);
var cliHash = TemplateHashExtensions.GenerateHashForCli(template.Identity);
var cliUpperHash = TemplateHashExtensions.GenerateHashForCliWithNormalizedCasing(template.Identity);
var cliLowerHash = TemplateHashExtensions.GenerateHashForCliWithNormalizedCasing(template.Identity, false);
sb.AppendLine($"{template.Identity},{hash},{hashLower},{idhash},{idhashLower},{groupIdHash},{groupIdHashLower},{cliHash},{cliUpperHash},{cliLowerHash}");
}
}
var templateCacheFilepath = optionTemplateCacheFilepath.HasValue() ?
optionTemplateCacheFilepath.Value() :
null;
var idsFromTemplateCacheFile = GetIdsFromTemplateCache(templateCacheFilepath);
if (idsFromTemplateCacheFile != null && idsFromTemplateCacheFile.Count > 0)
{
foreach (var id in idsFromTemplateCacheFile)
{
var hash = string.Empty;
var hashLower = string.Empty;
var idhash = TemplateHashExtensions.GenerateHash(id);
var idhashLower = TemplateHashExtensions.GenerateHash(id.ToLowerInvariant());
var groupIdHash = string.Empty;
var groupIdHashLower = string.Empty;
var cliHash = TemplateHashExtensions.GenerateHashForCli(id);
var cliUpperHash = TemplateHashExtensions.GenerateHashForCliWithNormalizedCasing(id);
var cliLowerHash = TemplateHashExtensions.GenerateHashForCliWithNormalizedCasing(id, false);
sb.AppendLine($"{id},{hash},{hashLower},{idhash},{idhashLower},{groupIdHash},{groupIdHashLower},{cliHash},{cliUpperHash},{cliLowerHash}");
}
}
File.WriteAllText(destFile, sb.ToString());
return(1);
};
}
