public Task <ExportResult> Handle(ExportPageDataCommand request, CancellationToken cancellationToken)
    {
        var pgExp = new ZippedJsonExporter <PageEntity>(_pageRepository, "moonglade-pages", ExportManager.DataDir);

        return(pgExp.ExportData(p => new
        {
            p.Id,
            p.Title,
            p.Slug,
            p.MetaDescription,
            p.HtmlContent,
            p.CssContent,
            p.HideSidebar,
            p.IsPublished,
            p.CreateTimeUtc,
            p.UpdateTimeUtc
        }, cancellationToken));
    }
    public Task <ExportResult> Handle(ExportPostDataCommand request, CancellationToken cancellationToken)
    {
        var poExp        = new ZippedJsonExporter <PostEntity>(_postRepository, "moonglade-posts", ExportManager.DataDir);
        var poExportData = poExp.ExportData(p => new
        {
            p.Title,
            p.Slug,
            p.ContentAbstract,
            p.PostContent,
            p.CreateTimeUtc,
            p.CommentEnabled,
            p.PostExtension.Hits,
            p.PostExtension.Likes,
            p.PubDateUtc,
            p.ContentLanguageCode,
            p.IsDeleted,
            p.IsFeedIncluded,
            p.IsPublished,
            Categories = p.PostCategory.Select(pc => pc.Category.DisplayName),
            Tags       = p.Tags.Select(pt => pt.DisplayName)
        }, cancellationToken);

        return(poExportData);
    }
Esempio n. 3
0
        public async Task <ExportResult> ExportData(ExportDataType dataType, CancellationToken cancellationToken)
        {
            switch (dataType)
            {
            case ExportDataType.Tags:
                var tagExp        = new CSVExporter <TagEntity>(_tagRepository, "moonglade-tags", _dataDir);
                var tagExportData = await tagExp.ExportData(p => new
                {
                    p.Id,
                    p.NormalizedName,
                    p.DisplayName
                }, cancellationToken);

                return(tagExportData);

            case ExportDataType.Categories:
                var catExp        = new CSVExporter <CategoryEntity>(_catRepository, "moonglade-categories", _dataDir);
                var catExportData = await catExp.ExportData(p => new
                {
                    p.Id,
                    p.DisplayName,
                    p.RouteName,
                    p.Note
                }, cancellationToken);

                return(catExportData);

            case ExportDataType.FriendLinks:
                var fdExp        = new CSVExporter <FriendLinkEntity>(_friendlinkRepository, "moonglade-friendlinks", _dataDir);
                var fdExportData = await fdExp.ExportData(p => p, cancellationToken);

                return(fdExportData);

            case ExportDataType.Pages:
                var pgExp        = new ZippedJsonExporter <PageEntity>(_pageRepository, "moonglade-pages", _dataDir);
                var pgExportData = await pgExp.ExportData(p => new
                {
                    p.Id,
                    p.Title,
                    p.Slug,
                    p.MetaDescription,
                    p.HtmlContent,
                    p.CssContent,
                    p.HideSidebar,
                    p.IsPublished,
                    p.CreateTimeUtc,
                    p.UpdateTimeUtc
                }, cancellationToken);

                return(pgExportData);

            case ExportDataType.Posts:
                var poExp        = new ZippedJsonExporter <PostEntity>(_postRepository, "moonglade-posts", _dataDir);
                var poExportData = await poExp.ExportData(p => new
                {
                    p.Title,
                    p.Slug,
                    p.ContentAbstract,
                    p.PostContent,
                    p.CreateTimeUtc,
                    p.CommentEnabled,
                    p.PostExtension.Hits,
                    p.PostExtension.Likes,
                    p.PubDateUtc,
                    p.ContentLanguageCode,
                    p.ExposedToSiteMap,
                    p.IsDeleted,
                    p.IsFeedIncluded,
                    p.IsPublished,
                    Categories = p.PostCategory.Select(pc => pc.Category.DisplayName),
                    Tags       = p.Tags.Select(pt => pt.DisplayName)
                }, cancellationToken);

                return(poExportData);

            default:
                throw new ArgumentOutOfRangeException(nameof(dataType), dataType, null);
            }
        }