interface PostContent {
    categories: string[];	// 分类
    dateCreated: Date;		// 创建日期
    description: string;	// 文章内容
    title: string;			// 文章标题
    mt_keywords: string;	// 标签
    wp_slug: string;		// 自定义 Web 链接
}

interface MediaObject {
    overwrite: boolean;
    bits: Buffer;			// 多媒体二进制数据
    name: string;			// 文件名
    type: string;			// MIME 类型
}

interface Category {
    categoryid: string;		// 分类ID
    description: string;	// 分类描述
    title: string;			// 分类名称
}

interface NewMediaObjectReturnType {
    url: string;			// 媒体文件访问地址
}

interface GetUserBlogsReturnType {
    blogid: string		// 博客 ID
    blogName: string	// 博客名称
}

import * as express from 'express';
import * as path from 'path';
import * as favicon from 'serve-favicon';
import * as logger from 'morgan';
import * as cookieParser from 'cookie-parser';
import * as bodyParser from 'body-parser';
import * as xrpc from "xrpc";
import { newPost, getPost, editPost, getCategories, newMediaObject } from './metaweblog';
import { getUserBlogs } from './blogger';

var app = express();

class ExpressError extends Error {
  status: number;
}

app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

/**
 * 增加的 xrpc 部分
 */
app.use(xrpc.xmlRpc);
app.post('/RPC', xrpc.route({
  metaWeblog: {
    newPost: newPost,
    getPost: getPost,
    getCategories: getCategories,
    newMediaObject: newMediaObject
  },
  blogger: {
    getUsersBlogs: getUserBlogs,
  }
}));
/**
 * RPC
 */

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new ExpressError('Not Found');
  err.status = 404;
  next(err);
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

module.exports = app;

import * as md5 from "md5";
import * as fs from "fs-extra";
import * as simplegit from "simple-git/promise";
import * as path from "path";
import * as moment from "moment";
import * as Hexo from "hexo";
import { Stream } from "stream";
const config = require("./package.json");
const blog = config.meta.blog

class ExpressError extends Error {
    status: number;

    constructor(msg, code) {
        super(msg);
        this.status = code;
    }
}

const hexo = new Hexo(blog, {
    silent: true,
    safe: true
});

interface PostContent {
    categories: string[];
    dateCreated: Date;
    description: string;
    title: string;
    mt_keywords: string;
    wp_slug: string;
}

interface MediaObject {
    overwrite: boolean;
    bits: Buffer;
    name: string;
    type: string;
}

export async function newPost(blogid: string, username: string, password: string, post: PostContent, publish: boolean, callback: Function) {
    if (blogid) {
        if (username.toLowerCase() === "hpdell" && md5(password) === "2b759a6996d878c41bb7d56ce530d031") {
            const git = simplegit(blog);
            if (await git.checkIsRepo()) {
                try {
                    let postInfo = (await fs.readFile(path.resolve(path.join(blog, "scaffolds", "post.md")))).toString();
                    postInfo = postInfo.replace("{{ title }}", post.title);
                    postInfo = postInfo.replace("{{ date }}", moment(post.dateCreated).format("YYYY-MM-DD HH:mm:ss"));
                    if (post.categories && post.categories.length) {
                        postInfo = postInfo.replace("categories:", `categories: ${post.categories[0]}`);
                    }
                    if (post.mt_keywords) {
                        let tags = post.mt_keywords.split(",");
                        let tagInfo = tags.map(item => `    - ${item}`).join("\n");
                        postInfo = postInfo.replace("tags:", `tags:\n${tagInfo}`);
                    }
                    let content = postInfo + post.description;
                    let postPath = path.resolve(path.join(blog, "source", "_posts", `${post.wp_slug}.md`));
                    try {
                        await fs.writeFile(postPath, content);
                        try {
                            await publishToGitHub(git, path.join("source", "_posts", `${post.wp_slug}.md`));
                            callback(null, post.wp_slug);
                        } catch (error) {
                            callback(new ExpressError((error as Error).message, 500));
                        }
                    } catch (error) {
                        callback(new ExpressError("Internal Server Error: Cannot write post file.", 500));
                    }
                } catch (error) {
                    callback(new ExpressError("Internal Server Error: Cannot read scaffolds.", 500));
                }
            } else {
                callback(new ExpressError("Inernal Server Error: Not a hexo repo.", 500));
            }
        } else {
            callback(new ExpressError("Username or Password is wrong.", 500));
        }
    } else {
        callback(new ExpressError("Blog id is required.", 500));
    }
}

export async function getPost(postid: string, username: string, password: string, callback: Function) {
    try {
        await hexo.load()
        let posts = hexo.locals.get("posts").filter((v, i) => v.title === postid).toArray();
        if (posts && posts.length) {
            let post = posts[0];
            let postStructure: PostContent = {
                categories: post.categories,
                dateCreated: post.date.toDate(),
                description: post.content,
                title: post.title,
                mt_keywords: post.tags.join(","),
                wp_slug: path.basename(post.path)
            };
            callback(null, postStructure)
        }
    } catch (error) {
        callback(new ExpressError("Post not found", 500));
    }
}

export function getCategories(blogid: string, username: string, password: string, callback: Function) {
    callback(null, config.meta.categories.map((item: string) => {
        return {
            categoryid: item,
            description: item,
            title: item
        }
    }));
}

export async function newMediaObject(blogid: string, username: string, password: string, mediaObject: MediaObject, callback: Function) {
    if (blogid) {
        if (username.toLowerCase() === "hpdell" && md5(password) === "2b759a6996d878c41bb7d56ce530d031") {
            let imgPath = path.join(blog, "source", "assets", "img", mediaObject.name);
            try {
                await fs.writeFile(imgPath, mediaObject.bits);
                callback(null, {
                    url: "/" + ["assets", "img", mediaObject.name].join("/")
                })
            } catch (error) {
                callback(new ExpressError("Writefile Wrong.", 500));
            }
        } else {
            callback(new ExpressError("Username or Password is wrong.", 500));
        }
    } else {
        callback(new ExpressError("Blog id is required.", 500));
    }
}

async function publishToGitHub(git: simplegit.SimpleGit, postPath) {
    try {
        let imgDirPath = path.join("source", "assets", "img", "*");
        await git.add([postPath, imgDirPath]);
        await git.commit(`Add Post: ${path.basename(postPath)}`);
        await git.pull("origin", "master", {
            "--rebase": "true"
        });
        await git.push();
    } catch (error) {
        throw new Error("git error");
    }
}

export function getUserBlogs(key: string, username: string, password: string, callback: Function) {
    console.log('getuserblogs called with key:', key, 'username:', username, 'and password:', password);
    callback(null, [{ blogid: 'hpdell-hexo', blogName: 'HPDell 的 Hexo 博客', }]);
}