public IEnumerator <object[]> GetEnumerator()
{
foreach (object[] objects in Directory.EnumerateFiles(TestUtility.TestSite.AssetsRoot, "*.md", SearchOption.AllDirectories)
.Select(file => new object[]
{
Path.GetFileNameWithoutExtension(file),
file,
File.ReadAllText(file)
}))
{
yield return(objects);
}
foreach (string file in Directory.EnumerateFiles(TestUtility.TestSite.AssetsRoot, "*.md.gen", SearchOption.AllDirectories))
{
foreach ((string path, PageResource value) in SiteBuilder.ProcessGenerator(TestUtility.TestSite, null,
new PageResource(file, ResourceType.Generator, ResourceLocation.Site)))
{
yield return(new object[]
{
Path.GetFileNameWithoutExtension(path),
path,
value.MarkdownText
});
}
}
}
void SetsSiteToCtorPassedSite()
{
var site = new SiteBuilder().Build();
var consumption = new Consumption(site);
Assert.Equal(site.Name, consumption.Site.Name);
}
public async Task TestRenderContent()
{
// Setup: Prepare our test by copying our `demo` folder into our "fake" file system.
var workspace = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "../../../../"));
var templatePath = Path.Combine(workspace, "Lockdown", "demo", "templates");
var dictionary = new Dictionary <string, MockFileData>();
foreach (var path in Directory.EnumerateFiles(templatePath))
{
var fakePath = path.Replace(templatePath, Path.Combine(inputPath, "templates"));
dictionary.Add(fakePath, new MockFileData(File.ReadAllBytes(path)));
}
var fakeFileSystem = new MockFileSystem(dictionary);
var metadata = new RawPostMetadata {
Title = "Test post", Date = new DateTime(2000, 1, 1)
};
var postContent = "Hola Mundo!" + Environment.NewLine + "Hola";
var siteBuilder = new SiteBuilder(fakeFileSystem);
// Act
var convertedPost = siteBuilder.RenderContent(metadata, postContent, inputPath);
// Assert
var html = await this.ParseHtml(convertedPost);
var heading1 = html.All.First(node => node.LocalName == "h1");
heading1.TextContent.ShouldBe("Test post");
}
void CreatesEmptyApplianceUsages()
{
var site = new SiteBuilder().Build();
var consumption = new Consumption(site);
Assert.Empty(consumption.ApplianceUsages);
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
SiteData data = (SiteData)e.Argument;
SiteBuilder builder = new SiteBuilder();
builder.ProgressReport += new SiteBuilder.ProgressReportDelegate(builder_ProgressReport);
this.InstallWorked = builder.CreateSite(data);
}
public IEnumerable <string> GetSiteNames(string connectionString)
{
var manager = new SiteFactoryManager(connectionString);
var list = manager.SearchAllEntities().ToList();
return(SiteBuilder.NewSiteBuilder()
.BuildAll(list));
}
void GetsSiteNumSolarHours()
{
var site = new SiteBuilder().Build();
var consumption = new Consumption(site);
var expectedHrs = site.NumSolarHours;
Assert.Equal(expectedHrs,
consumption.ReadOnlySiteSettings.NumSolarHours);
}
public void TestOutputFolderDoesNotExist()
{
// Setup
var siteBuilder = new SiteBuilder(fakeFileSystem);
// Act
siteBuilder.CleanFolder(output);
// Asserts
this.AssertDirectoryIsEmpty(output);
}
public ISite LoadSite(string connectionString, string name, IAlarmClock alarmClock)
{
var siteManager = new SiteFactoryManager(connectionString);
var siteEntity = siteManager.SearchEntity(name) ?? throw new InexistentNameException(name);
var site = SiteBuilder.NewSiteBuilder()
.SetConnectionString(connectionString)
.SetAlarmClock(alarmClock)
.SetEntity(siteEntity)
.Build();
return(site);
}
void GetsUpdatedSiteNumSolarHours()
{
var site = new SiteBuilder().Build();
var consumption = new Consumption(site);
var hrs = site.NumSolarHours + 1; // add an hour
var ti = site.PeakSolarInterval;
int startHr = ti.Start.Hours, startMin = ti.Start.Minutes;
int endHr = ti.End.Hours, endMin = ti.End.Minutes;
site.SetPeakSolarInterval(new TimeInterval(startHr, startMin,
endHr + 1, endMin));
Assert.Equal(hrs,
consumption.ReadOnlySiteSettings.NumSolarHours);
}
public void ShouldCalcTheCorrectTotals(
List <CompactApplianceUsage> inApplianceUsages,
decimal expMaxPowerConsumption,
decimal expTotalPowerConsumption,
decimal expTotalOnSolarEnergyConsumption,
decimal expTotalOffSolarEnergyConsumption,
decimal expTotalEnergyConsumption)
{
var site = new SiteBuilder().Build();
for (int i = 0; i < inApplianceUsages.Count; ++i)
{
// Add a new Applianceusage
var appliance = new ApplianceBuilder().Build();
site.Consumption.AddApplianceUsage(appliance);
// Modify it based on the passed test data
var applianceUsage = site.Consumption.ApplianceUsages.Last();
// Rem the default usage interval
applianceUsage.ApplianceUsageSchedule.ClearUsageIntervals();
var inApplianceUsage = inApplianceUsages[i];
applianceUsage.SetQuantity(inApplianceUsage.Quantity);
applianceUsage.SetPowerConsumption(
inApplianceUsage.PowerConsumption);
foreach (var uti in inApplianceUsage.UsageIntervals)
{
var ti = uti.TimeInterval;
int startHr = ti.Start.Hours, startMin = ti.Start.Minutes;
int endHr = ti.End.Hours, endMin = ti.End.Minutes;
applianceUsage.ApplianceUsageSchedule.AddUsageInterval(
startHr, startMin, endHr, endMin, uti.UsageKind
);
}
applianceUsage.Recalculate();
}
site.Consumption.Recalculate();
Assert.Equal(expMaxPowerConsumption,
site.Consumption.ConsumptionTotal.MaxPowerConsumption);
Assert.Equal(expTotalPowerConsumption,
site.Consumption.ConsumptionTotal.TotalPowerConsumption);
Assert.Equal(expTotalOnSolarEnergyConsumption,
site.Consumption.ConsumptionTotal
.TotalOnSolarEnergyConsumption);
Assert.Equal(expTotalOffSolarEnergyConsumption,
site.Consumption.ConsumptionTotal
.TotalOffSolarEnergyConsumption);
Assert.Equal(expTotalEnergyConsumption,
site.Consumption.ConsumptionTotal.TotalEnergyConsumption);
}
public void TestOutputFolderExist()
{
// Setup
var fakeFilePath = fakeFileSystem.Path.Combine(output, "archivo.txt");
fakeFileSystem.Directory.CreateDirectory(output);
fakeFileSystem.File.WriteAllText(fakeFilePath, "hola mundo");
var siteBuilder = new SiteBuilder(fakeFileSystem);
// Act
siteBuilder.CleanFolder(output);
// Asserts
this.AssertDirectoryIsEmpty(output);
}
public async Task Build_site()
{
/* Given */
var collector = new SectionCollector();
await _catalog.Add(_aggregator.Aggregate(CancellationToken.None));
await collector.Collect(_catalog);
var sut = new SiteBuilder(_site);
/* When */
var site = sut.Add(collector.Sections)
.Build();
/* Then */
Assert.NotEmpty(site.Versions);
}
static void Main(string[] args)
{
/* if(args.Length != 2)
* {
* Console.WriteLine("Usage: dotnet run [databaseType] [databaseName]");
* Console.WriteLine(".NET Core site-generator allows creating a working CRUD website with separated frontend and api server from a Database model.");
* Console.WriteLine("");
* Console.WriteLine(" Arguments:");
* Console.WriteLine(" [databaseType]: (postgres)");
* Console.WriteLine(" [databaseName]: Name of the Postgres database to fetch website model structure.");
* Console.WriteLine(" [databaseName]: Name of the Postgres database to fetch website model structure.");
* Console.WriteLine("");
* return;
* }
*
* SiteBuilder.BuildWebsite(args[0], args[1]);*/
SiteBuilder.BuildWebsite("postgres", "postgres");
}
public void TestGetPostsWithSinglePost(int files)
{
var postsPath = this.fakeFileSystem.Path.Combine(inputPath, "posts");
this.fakeFileSystem.Directory.CreateDirectory(postsPath);
var fileContents = new List <string>();
for (var i = 0; i < files; i++)
{
var postPath = this.fakeFileSystem.Path.Combine(postsPath, $"file_{i}.txt");
var content = "# Hola Mundo!\n\n**Prueba {i}**";
this.fakeFileSystem.File.WriteAllText(postPath, content);
fileContents.Add(content);
}
var siteBuilder = new SiteBuilder(this.fakeFileSystem);
var posts = siteBuilder.GetPosts(inputPath);
posts.OrderBy(content => content).ShouldBe(fileContents);
}
static void Main(string[] args)
{
string version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
Console.WriteLine("Create MT Store | " + version);
Console.WriteLine();
if (args.Length < 6)
{
ShowHelp();
return;
}
Console.WriteLine("Parsing Arguments");
SiteData data = new SiteData();
data.InstallSourceCode = true;
data.SourceFolder = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\src\\";
foreach (string arg in args)
{
ParseArg(data, arg);
}
data.PrepArgs();
SiteBuilder builder = new SiteBuilder();
builder.ProgressReport += new SiteBuilder.ProgressReportDelegate(builder_ProgressReport);
if (builder.CreateSite(data))
{
Console.WriteLine("Create store SUCCESS!");
}
else
{
Console.WriteLine("Create store FAILED!");
}
}
public void TestCopyFiles()
{
// Setup
var stylesFile = this.fakeFileSystem.Path.Combine(inputPath, "style.css");
var someOtherFile = this.fakeFileSystem.Path.Combine(inputPath, "subfolder", "style.css");
var contents = new Dictionary <string, MockFileData>
{
{ stylesFile, new MockFileData("body { color: #fff; }") },
{ someOtherFile, new MockFileData("more data") }
};
var fakeFileSystem = new MockFileSystem(contents);
fakeFileSystem.Directory.CreateDirectory(output);
var siteBuilder = new SiteBuilder(fakeFileSystem);
// Act
siteBuilder.CopyFiles(inputPath, output);
// Assert
fakeFileSystem.Directory.EnumerateFiles(output, "*.*", SearchOption.AllDirectories).Count().ShouldBe(2);
}
// wolf howling
private static void Main(string[] args)
{
SiteBuilder e = new SiteBuilder();
e.Build();
}
public async Task TestBuild()
{
MockFileSystem.File.Exists(Path.Combine(ExitDirectory, "index.html")).ShouldBeFalse();
var siteBuilder = new SiteBuilder(MockFileSystem, Mapper.GetMapper());
siteBuilder.Build(RootDirectory, ExitDirectory);
var indexFile = Path.Combine(ExitDirectory, "index.html");
MockFileSystem.File.Exists(indexFile).ShouldBeTrue();
var indexDocument = await OpenDocument(indexFile);
var sections = indexDocument.All.Where(node => node.LocalName == "section");
sections.Count().ShouldBe(2);
var titleContainer = indexDocument.All.First(node => node.LocalName == "div" && node.ClassName == "main");
titleContainer.TextContent.Trim().ShouldBe("Your new blog!");
var subTitleContainer = indexDocument.All.First(node => node.LocalName == "div" && node.ClassName == "site-description");
subTitleContainer.TextContent.Trim().ShouldBe("Edit this subtitle in the site.yml file");
var secondPostFile = Path.Combine(ExitDirectory, "posts", "second-post.html");
MockFileSystem.File.Exists(secondPostFile).ShouldBeTrue();
var secondPost = await OpenDocument(secondPostFile);
var title = secondPost.All.First(node => node.LocalName == "h1");
title.TextContent.ShouldBe("My second post!");
var pageFile = Path.Combine(ExitDirectory, "pages", "about.html");
MockFileSystem.File.Exists(pageFile).ShouldBeTrue();
var page = await OpenDocument(pageFile);
var pageTitle = page.All.First(node => node.LocalName == "h1");
pageTitle.TextContent.ShouldBe("About");
var tagseFile = Path.Combine(ExitDirectory, "tags.html");
MockFileSystem.File.Exists(tagseFile).ShouldBeTrue();
var tagsPage = await OpenDocument(tagseFile);
var tags = tagsPage.All.Where(node => node.LocalName == "li").Select(tag => tag.TextContent).ToArray();
tags.ShouldBe(new string[] { "lockdown", "blog" });
var lockdownTagsFile = Path.Combine(ExitDirectory, "tags", "lockdown.html");
MockFileSystem.File.Exists(Path.Combine(ExitDirectory, "tags", "lockdown.html")).ShouldBeTrue();
var lockdownPostsPage = await OpenDocument(lockdownTagsFile);
var pageTitles = lockdownPostsPage.All.Where(node => node.LocalName == "h1" && node.ClassName == "title").Select(h1 => h1.TextContent).ToArray();
pageTitles.ShouldBe(new string[] { "My first post!", "My second post!" });
}
private static async Task MainLoop(Arguments arguments)
{
try
{
await ProgramLoop();
}
catch (Exception e)
{
LogExitException(e, "Operation failed!");
}
async Task ProgramLoop()
{
while (true)
{
Console.WriteLine("Press key to proceed:");
Console.WriteLine(" B - Build site");
Console.WriteLine(" C - Content build only");
Console.WriteLine(" U - Log external URLs");
#if WINDOWS
Console.WriteLine(" R - Create rich-text embed from clipboard");
#endif
Console.WriteLine(" Esc - Exit");
Read:
var key = Console.ReadKey().Key;
Console.WriteLine();
Console.Clear();
switch (key)
{
case ConsoleKey.B:
// Build Site
if (SiteBuilder.Build(arguments))
{
Console.WriteLine("Successful build, generating search index.");
await SearchIndex.Generate(arguments);
Console.WriteLine("Search index generated.");
}
else
{
Console.WriteLine("Build failed! Press key to continue.");
Console.ReadKey();
Console.Clear();
}
break;
case ConsoleKey.C:
// Content Build
SiteBuilder.ContentBuild(arguments);
Console.WriteLine("Successful Content Build.");
break;
case ConsoleKey.U:
SiteLogging.LogAllExternalUrls(arguments);
break;
#if WINDOWS
case ConsoleKey.R:
RtfClip.CreateRtfFile(arguments);
break;
#endif
case ConsoleKey.Escape:
return;
default:
goto Read;
}
}
}
}
/// <summary>
/// Add the main edity services. If you call this and can use the default IFileFinder, you don't need to
/// do anything else, if you want to customize the file finder add it before calling this function.
/// </summary>
/// <param name="services">The services collection.</param>
/// <param name="setupEditySettings">Callback to configure the edity settings.</param>
/// <returns>The service collection.</returns>
public static IServiceCollection AddEdity(this IServiceCollection services, Action <EditySettings> setupEditySettings)
{
services.AddThreaxSharedHttpClient();
var editySettings = new EditySettings();
setupEditySettings.Invoke(editySettings);
//Setup the mapper
var mapperConfig = SetupMappings();
services.AddScoped <IMapper>(i => mapperConfig.CreateMapper());
//Setup repos
services.TryAddScoped <ICommitRepository, CommitRepository>();
services.TryAddScoped <ISyncRepository, SyncRepository>();
services.TryAddScoped <IPathBaseInjector, PathBaseInjector>();
services.TryAddScoped <IDraftRepository, DraftRepository>();
services.TryAddScoped <IPublishRepository, PublishRepository>();
services.TryAddScoped <IHistoryRepository, HistoryRepository>();
services.TryAddScoped <IMergeRepository, MergeRepository>();
services.TryAddScoped <IPageRepository, PageRepository>();
services.TryAddScoped <ITemplateRepository, TemplateRepository>();
services.TryAddScoped <IAssetRepository, AssetRepository>();
services.TryAddScoped <IBranchRepository, BranchRepository>();
services.TryAddSingleton <IOverrideValuesProvider>(s => new DefaultOverrideValuesProvider(editySettings.OverrideVars));
services.TryAddScoped <IGitCredentialsProvider, DefaultGitCredentialsProvider>();
var baseUrl = HalcyonConventionOptions.HostVariable;
if (editySettings.BaseUrl != null)
{
baseUrl += "/" + editySettings.BaseUrl;
}
var halOptions = new HalcyonConventionOptions()
{
BaseUrl = baseUrl,
HalDocEndpointInfo = new HalDocEndpointInfo(typeof(EndpointDocController)),
MakeAllControllersHalcyon = false
};
services.AddConventionalHalcyon(halOptions);
var halClientGenOptions = new HalClientGenOptions()
{
SourceAssemblies = new Assembly[] { typeof(EdityMvcExtensions).GetTypeInfo().Assembly }
};
if (editySettings.AdditionalMvcLibraries != null)
{
halClientGenOptions.SourceAssemblies = halClientGenOptions.SourceAssemblies.Concat(editySettings.AdditionalMvcLibraries);
}
services.AddHalClientGen(halClientGenOptions);
if (editySettings.Events == null)
{
editySettings.Events = new EdityEvents();
}
services.TryAddScoped <ITargetFileInfoProvider>(s =>
{
var fileFinder = s.GetRequiredService <IFileFinder>();
return(new DefaultTargetFileInfoProvider(fileFinder.Project.DefaultPage));
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.TryAddSingleton <WorkQueue, WorkQueue>();
services.TryAddSingleton <ICompileService>(s => new CompileService(s.GetRequiredService <WorkQueue>(), mapperConfig.CreateMapper()));
services.TryAddScoped <IUserInfo, DefaultUserInfo>();
services.TryAddScoped <IPhaseDetector>(s =>
{
var settings = new JsonSerializerSettings();
settings.SetToHalcyonDefault();
var serializer = JsonSerializer.Create(settings);
return(new CookiePhaseDetector("edityBranch", serializer, s.GetRequiredService <IHttpContextAccessor>()));
});
services.AddSingleton <EditySettings>(s => editySettings);
switch (editySettings.ProjectMode)
{
case ProjectMode.OneRepo:
default:
services.AddTransient <ProjectFinder, OneRepo>(s =>
{
return(new OneRepo(editySettings.ProjectPath, editySettings.EdityCorePath, editySettings.SitePath));
});
break;
case ProjectMode.OneRepoPerUser:
services.AddTransient <ProjectFinder, OneRepoPerUser>(s =>
{
return(new OneRepoPerUser(editySettings, s.GetRequiredService <IPhaseDetector>(), s.GetRequiredService <ILogger <OneRepoPerUser> >()));
});
break;
}
services.AddTransient <Repository, Repository>(s =>
{
var userInfo = s.GetRequiredService <IUserInfo>();
var projectFinder = s.GetRequiredService <ProjectFinder>();
var projectFolder = projectFinder.GetUserProjectPath(userInfo.UniqueUserName);
return(new Repository(Repository.Discover(projectFolder)));
});
services.AddTransient <Signature, Signature>(s =>
{
var userInfo = s.GetRequiredService <IUserInfo>();
return(new Signature(userInfo.PrettyUserName, userInfo.Email, DateTime.Now));
});
services.AddTransient <SiteBuilderSettings, SiteBuilderSettings>(s =>
{
return(new SiteBuilderSettings()
{
OutDir = editySettings.OutputPath
});
});
services.TryAddScoped <IContentCompilerFactory, ContentCompilerFactory>();
services.AddDefaultFileFinder();
services.AddSingleton <BuildTaskManager>(s =>
{
var buildTaskManager = new BuildTaskManager();
buildTaskManager.SetBuildTaskType("PublishMenu", typeof(PublishMenu));
buildTaskManager.SetBuildTaskType("CreateIISWebConfig", typeof(CreateIISWebConfig));
buildTaskManager.SetBuildTaskType("GetPublishRepo", typeof(GetPublishRepo));
buildTaskManager.SetBuildTaskType("PublishToGitRepo", typeof(PublishToGitRepo));
buildTaskManager.SetBuildTaskType("AddGithubCname", typeof(AddGithubCname));
editySettings.Events.CustomizeBuildTasks?.Invoke(buildTaskManager);
return(buildTaskManager);
});
services.TryAddTransient <PullPublish>(s =>
{
var projectFinder = s.GetRequiredService <ProjectFinder>();
return(new PullPublish(projectFinder.MasterRepoPath, projectFinder.PublishedProjectPath));
});
services.AddTransient <ISiteBuilder>(s =>
{
var settings = s.GetRequiredService <SiteBuilderSettings>();
var compilerFactory = s.GetRequiredService <IContentCompilerFactory>();
var fileFinder = s.GetRequiredService <IFileFinder>();
String deploymentFolder = null;
if (editySettings.Publisher == Publishers.RoundRobin)
{
deploymentFolder = Guid.NewGuid().ToString();
}
var builder = new SiteBuilder(settings, compilerFactory, fileFinder, deploymentFolder);
var buildTaskManager = s.GetRequiredService <BuildTaskManager>();
//Customize publisher settings depending on compiler setting
switch (editySettings.Publisher)
{
case Publishers.RoundRobin:
var outputBaseFolder = settings.OutDir;
settings.OutDir = Path.GetFullPath(Path.Combine(settings.OutDir, deploymentFolder));
builder.AddPublishTask(new RoundRobinPublisher(settings.OutDir));
break;
}
if (editySettings.ProjectMode == ProjectMode.OneRepoPerUser)
{
builder.AddPreBuildTask(s.GetRequiredService <PullPublish>());
}
foreach (var preBuild in fileFinder.Project.PreBuildTasks)
{
builder.AddPreBuildTask(buildTaskManager.CreateBuildTask(preBuild));
}
foreach (var postBuild in fileFinder.Project.PostBuildTasks)
{
builder.AddPostBuildTask(buildTaskManager.CreateBuildTask(postBuild));
}
foreach (var publish in fileFinder.Project.PublishTasks)
{
builder.AddPublishTask(buildTaskManager.CreateBuildTask(publish));
}
foreach (var postPublish in fileFinder.Project.PostPublishTasks)
{
builder.AddPostPublishTask(buildTaskManager.CreateBuildTask(postPublish));
}
editySettings.Events.CustomizeSiteBuilder(new SiteBuilderEventArgs()
{
SiteBuilder = builder,
Services = s
});
return(builder);
});
services.AddExceptionErrorFilters(new ExceptionFilterOptions()
{
DetailedErrors = editySettings.DetailedErrors
});
// Add framework services.
var mvcBuilder = services.AddMvc(o =>
{
o.UseExceptionErrorFilters();
o.UseConventionalHalcyon(halOptions);
})
.AddNewtonsoftJson(o =>
{
o.SerializerSettings.SetToHalcyonDefault();
o.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
})
.AddEdityControllers(editySettings.AdditionalMvcLibraries);
editySettings.Events.CustomizeMvcBuilder?.Invoke(mvcBuilder);
services.AddScoped <ICompileRequestDetector, CompileRequestDetector>();
services.AddSingleton <IFileVerifier>(s =>
{
var verifier = new FileVerifier()
.AddHtml()
.AddBitmap()
.AddJpeg()
.AddPng()
.AddSvgXml()
.AddGif()
.AddPdf()
.AddDocx()
.AddDoc()
.AddPptx()
.AddPpt()
.AddXlsx()
.AddXls()
.AddJson();
editySettings.Events.CustomizeFileVerifier?.Invoke(verifier);
return(verifier);
});
services.AddScoped <IToolRunner>(s =>
{
var tools = new ToolRunner()
.UseClientGenTools();
editySettings.Events.CustomizeTools?.Invoke(tools);
return(tools);
});
services.AddThreaxProcessHelper(o =>
{
//o.IncludeLogOutput = false;
//o.DecorateProcessRunner = r => new SpyProcessRunner(r)
//{
// Events = new ProcessEvents()
// {
// ErrorDataReceived = (o, e) => { if (e.DataReceivedEventArgs.Data != null) Console.WriteLine(e.DataReceivedEventArgs.Data); },
// OutputDataReceived = (o, e) => { if (e.DataReceivedEventArgs.Data != null) Console.WriteLine(e.DataReceivedEventArgs.Data); },
// }
//};
});
return(services);
}
