static async Task Work(DirectoryInfo output)
{
if (!output.Exists)
{
output.Create();
}
DirectoryInfo postDist = output.CreateSubdirectory("posts");
var loader = new PostsLoader(new DirectoryInfo(Path.Join(Environment.CurrentDirectory, "posts")));
var ls = await loader.LoadAll();
var postBuilder = new PostRepositoryBuilder(ls, postDist)
{
Protector = new PostProtector(),
CountPerPage = 10,
};
await postBuilder.Build();
{
KeywordRepositoryBuilder builder = new KeywordRepositoryBuilder(postBuilder.Keywords, output.CreateSubdirectory("keywords"));
await builder.Build();
}
{
CategoryRepositoryBuilder builder = new CategoryRepositoryBuilder(postBuilder.Categories, output.CreateSubdirectory("categories"));
await builder.Build();
}
}
// full: delete diff post for api remote
public async Task Push(string name = "", bool full = false)
{
if (string.IsNullOrEmpty(name))
{
name = Option.CurrentRemote;
}
Logger.LogInformation($"Push to remote {name}.");
if (Option.Remotes.TryGetValue(name, out var remote))
{
Logger.LogInformation($"Detect remote {remote.Name} ({Enum.GetName(typeof(RemoteType), remote.Type)}).");
switch (remote.Type)
{
case RemoteType.LocalFS:
{
await toLocalFS(remote);
}
break;
case RemoteType.RemoteFS:
{
throw new NotSupportedException("Not support pushing to remote file system, please push to local file system and sync to remote.");
}
case RemoteType.Api:
{
await Connect(name);
Logger.LogInformation($"Fetch remote posts.");
HashSet <string> remoteIds = (await Remote.PostService.All()).ToHashSet();
foreach (var item in await Local.PostService.GetAllPosts())
{
if (item is null)
{
continue;
}
Logger.LogInformation($"Loaded {item.Id}: {item.Title}");
if (remoteIds.Contains(item.Id))
{
var result = await Remote.PostService.Update(item);
if (result)
{
Logger.LogInformation($"Updated {item.Id}");
}
else
{
Logger.LogError($"Failed to update {item.Id}");
}
}
else
{
var result = await Remote.PostService.Create(item);
if (result is null)
{
Logger.LogError($"Failed to create {item.Id}");
}
else
{
Logger.LogInformation($"Created {item.Id}");
}
}
remoteIds.Remove(item.Id);
}
if (full)
{
foreach (var v in remoteIds)
{
var result = await Remote.PostService.Delete(v);
if (result)
{
Logger.LogInformation($"Deleted {v}.");
}
else
{
Logger.LogError($"Failed to deleted {v}.");
}
}
}
}
break;
case RemoteType.Git:
{
await Connect(name);
string tempDist = Path.Join(Environment.CurrentDirectory, "temp/dist");
Logger.LogInformation("Generate data.");
await toLocalFS(new RemoteOption
{
Uri = tempDist,
Type = RemoteType.LocalFS,
Name = remote.Name
});
FSExtensions.CopyDirectory(tempDist, GitTempFolder);
Logger.LogInformation("Load git config.");
string userName = Option.Properties[$"remote.{remote.Name}.git.username"],
password = Option.Properties[$"remote.{remote.Name}.git.password"];
{
if (string.IsNullOrEmpty(userName))
{
userName = ConsoleExtensions.Input("Input username: "******"Input password: "******"Commit to git.");
LibGit2Sharp.Commands.Stage(repo, "*");
var signature = new LibGit2Sharp.Signature(
new Identity("AcBlog.Tools.Sdk", "tools.sdk@acblog"), DateTimeOffset.Now);
repo.Commit(DateTimeOffset.Now.ToString(), signature, signature, new CommitOptions
{
AllowEmptyCommit = true
});
Logger.LogInformation($"Push to {repo.Head.RemoteName}.");
PushOptions options = new LibGit2Sharp.PushOptions();
options.CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = string.IsNullOrEmpty(userName) ? usernameFromUrl : userName,
Password = password
});
repo.Network.Push(repo.Head, options);
}
}
break;
}
}
else
{
throw new Exception("No remote");
}
async Task toLocalFS(RemoteOption remote)
{
FSBuilder fsBuilder = new FSBuilder(remote.Uri);
fsBuilder.EnsureDirectoryEmpty();
List <Post> posts = new List <Post>();
foreach (var item in await Local.PostService.GetAllPosts())
{
if (item is null)
{
continue;
}
Logger.LogInformation($"Loaded {item.Id}: {item.Title}");
posts.Add(item);
}
Logger.LogInformation("Build data.");
{
BlogOptions options = await Local.GetOptions();
BlogBuilder builder = new BlogBuilder(options, Path.Join(remote.Uri));
await builder.Build();
}
{
PostRepositoryBuilder builder = new PostRepositoryBuilder(posts, Path.Join(remote.Uri, "posts"));
await builder.Build();
}
{
var baseAddress = Option.Properties[$"remote.{remote.Name}.generator.baseAddress"];
if (!string.IsNullOrEmpty(baseAddress))
{
Logger.LogInformation("Build sitemap.");
var sub = fsBuilder.CreateSubDirectoryBuilder("Site");
{
var siteMapBuilder = await Local.BuildSitemap(baseAddress);
using var st = sub.GetFileRewriteStream("sitemap.xml");
using var writer = XmlWriter.Create(st);
siteMapBuilder.Build().WriteTo(writer);
}
Logger.LogInformation("Build feed.");
{
var feed = await Local.BuildSyndication(baseAddress);
using var st = sub.GetFileRewriteStream("atom.xml");
using var writer = XmlWriter.Create(st);
feed.GetAtom10Formatter().WriteTo(writer);
}
}
}
}
}
