register_rest_route('nv','get-editor-metas',{
methods: 'post',
callback(data,req) {
const {post_type} = data;
if (!post_type) {
return new NV_Error('参数错误');
}
//读取自定义metabox
var meta_boxs = apply_filters('_nv_custom_metaboxes',[])
.filter( r=>r.post_types.includes(post_type) )
.sort((a,b)=>{
return (a.position || 10) - (b.position || 10);
})
.map( r=>({
slug: r.meta_box_slug,
component_url: r.component_url,
content: r.content, // 有content是使用metabox组件,没有就是自定义
}) )
//读取taxonomies
var post_taxonomies = apply_filters('_nv_taxonomies',[])
.filter( r=> r.post_type == post_type)
.map(tax=> {
var hierarchical = tax.opts.hierarchical;
return {
taxonomy: tax.taxonomy,
name: tax.opts.labels.name,
hierarchical,
terms: get_terms({taxonomy: tax.taxonomy})
.map(r=>({
id:r.id,
name:r.name,
parent:hierarchical ? r.parent : undefined
})
)
}
})
//读取posttype
var current_posttype = apply_filters('_nv_posttypes',[])
.filter( r=>r.post_type == post_type )[0];
// 对于允许层级关系的文章类型。需要读取所有的内容(用于生成父、子树)。
var post_tree = [];
if (current_posttype.opts.hierarchical) {
post_tree = nvdb.posts.find(r=>r.post_type == post_type)
.sort((post1,post2)=>{
if (post1.order == post2.order) {
return post2.modified_time - post1.modified_time;
}
return post1.order - post2.order;
})
.map(r=>({ id: r.id, title: r.title, parent: r.parent, order: r.order}))
}
return {
meta_boxs,
post_taxonomies,
post_type_info: current_posttype,
post_tree,
}
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','get-post',{
methods: 'post',
callback(data,req) {
const {id,password} = data;
if (!id) {
return new NV_Error('参数错误');
}
var post = get_post(id);
if (is_nv_error(post)) {
return post;
}
//权限小于6(贡献者)的时候,若不是自己的文章,有密码时必须提供密码才可以访问
var user = get_user_by_nonce(req.headers.nvnonce);
var currentUserPower = user.power || 0;
if (currentUserPower <= 6 && post.author !== user.id && post.password.length > 0 && password !== post.password) {
return new NV_Error('密码错误',401.1);
}
//读取这个post对应posttype所注册的所有taxonomy
var post_taxs = get_taxonomies(post.post_type);
var taxonomies = { /*taxonomyName: [term_ids]*/ }
post_taxs.forEach(tax=>{
var terms = nv_get_object_terms(id, tax.taxonomy);
taxonomies[tax.taxonomy] = terms.map(term=>term.id)
})
return {
...post,
metas: get_post_meta(id),
taxonomies,
permalink: get_post_permalink(post),
}
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','add-post',{
methods: 'post',
callback(data,req) {
/*
metas: {
metaName: metaValue
}
taxonomies: {
taxonomyName: [term_ids]
}
*/
const {metas,taxonomies} = data;
var user = get_user_by_nonce(req.headers.nvnonce);
var user_id = user.id || 0;
var currentUserPower = user.power || 0;
var post_id = nv_insert_post({
author: user_id,
...data
})
if (is_nv_error(post_id)) {
return post_id;
}
//设置metas
for (var key in metas) {
update_post_meta(post_id, key, metas[key])
}
//设置taxonomy
for (var taxonomy in taxonomies) {
var term_ids = [];
// 如果是number,就是term_id,如果是string,那就说明需要新增
taxonomies[taxonomy].forEach(item => {
if ( typeof(item) == "number" ) {term_ids.push(item);return;}
//权限小于6(贡献者)时,只能选择现有term,不允许新增
if ( currentUserPower <= 6 ) { return; }
//先判断这个string是否是存在的term名称
var exist_term_id = term_exists(item, taxonomy);
if ( exist_term_id ) {term_ids.push(exist_term_id);return;}
var term_id = nv_insert_term( item, taxonomy,{});
if ( !is_nv_error(term_id) ) {term_ids.push(term_id);return;}
})
nv_set_object_terms(post_id, term_ids, taxonomy);
}
//读出这个文章
var current_post = get_post(post_id);
return {
id: current_post.id,
modified_time: current_post.modified_time,
slug: current_post.slug,
permalink: get_post_permalink(current_post),
};
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','update-post',{
methods: 'post',
callback(data,req) {
/*
metas: {
metaName: metaValue
}
taxonomies: {
taxonomyName: [term_ids]
}
*/
const {metas,taxonomies} = data;
//权限小于6(贡献者)的时候,若不是自己的文章,不予保存
var user = get_user_by_nonce(req.headers.nvnonce);
var currentUserPower = user.power || 0;
if (currentUserPower <= 6) {
var post = get_post(data.id);
if (!is_nv_error(post) && post.author !== user.id) {
return new NV_Error('只能编辑自己的文章',403.3);
}
//文章本身已经发布状态,重新保存时要变成草稿
if (post.status == 'publish' && data.status !=='pending') {
data.status = 'draft';
}
}
delete data.author;
delete data.created_time;
var post_id = nv_update_post(data);
if (is_nv_error(post_id)) {
return post_id;
}
//设置metas
for (var key in metas) {
update_post_meta(post_id, key, metas[key])
}
//设置taxonomy
for (var taxonomy in taxonomies) {
var term_ids = [];
// 如果是number,就是term_id,如果是string,那就说明需要新增
taxonomies[taxonomy].forEach(item => {
if ( typeof(item) == "number" ) {term_ids.push(item);return;}
//权限小于6(贡献者)时,只能选择现有term,不允许新增
if ( currentUserPower <= 6 ) { return; }
//先判断这个string是否是存在的term名称
var exist_term_id = term_exists(item, taxonomy);
if ( exist_term_id ) {term_ids.push(exist_term_id);return;}
var term_id = nv_insert_term( item, taxonomy,{});
if ( !is_nv_error(term_id) ) {term_ids.push(term_id);return;}
})
nv_set_object_terms(post_id, term_ids, taxonomy);
}
//读出这个文章
var current_post = get_post(post_id);
return {
id: current_post.id,
modified_time: current_post.modified_time,
slug: current_post.slug,
permalink: get_post_permalink(current_post),
};
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','delete-posts',{
methods: 'post',
callback(data,req) {
const {posts} = data;
//权限小于6(贡献者)的时候,若不是自己的文章,不予删除
var user = get_user_by_nonce(req.headers.nvnonce);
var currentUserPower = user.power || 0;
if (currentUserPower <= 6) {
var check = true;
posts.forEach(post_id=>{
var post = get_post(post_id);
if (!is_nv_error(post) && post.author !== user.id) {
check = check && false;
}
})
if (check == false) {
return new NV_Error('只能删除自己的文章',403.3);
}
}
posts.forEach(post_id=>{
nv_delete_post(post_id)
})
return {};
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','change-posts-author',{
methods: 'post',
callback(data,req) {
const {posts,author} = data;
var user_id = parseInt(author);
if (!posts || !author) {
return new NV_Error('参数错误');
}
nv_set_post_fields(posts,{
author: user_id
})
return {};
},
permission_callback: power=>power >= 10,
});
register_rest_route('nv','change-posts-comment-status',{
methods: 'post',
callback(data,req) {
const {posts,status} = data;
if (!posts) {
return new NV_Error('参数错误');
}
nv_set_post_fields(posts,{
comment_status: !!status
})
return {};
},
permission_callback: power=>power >= 10,
});
register_rest_route('nv','change-posts-password',{
methods: 'post',
callback(data,req) {
const {posts,password} = data;
if (!posts || typeof(password) !== 'string') {
return new NV_Error('参数错误');
}
nv_set_post_fields(posts,{ password })
return {};
},
permission_callback: power=>power >= 10,
});
register_rest_route('nv','get-admin-post-list-metas',{
methods: 'post',
callback(data,req) {
const {post_type} = data;
if (!post_type) {
return new NV_Error('参数错误');
}
//读取post_type
var post_types = apply_filters('_nv_posttypes',[]);
var post_type_info = post_types.filter(r=>r.post_type == post_type)[0] || {};
//读取taxonomies
var post_taxonomies = apply_filters('_nv_taxonomies',[])
.filter( r=> r.post_type == post_type)
.map(tax=> {
var hierarchical = tax.opts.hierarchical;
return {
taxonomy: tax.taxonomy,
name: tax.opts.labels.name,
hierarchical,
}
})
//读取表格列配置
var tax_cols = get_taxonomies(post_type).map(tax=>{
return { key: tax.taxonomy, title: tax.opts.labels.name, sort: '' }
})
var defaultColumns = post_type_info.opts.supports.includes('title')
? [{key: 'title', title: '标题', sort: 'title'}]
: [];
if ( post_type_info.opts.supports.includes('author') ) {
defaultColumns = [...defaultColumns,{key: 'author_name', title: '作者', sort: 'author'}]
}
defaultColumns = [ ...defaultColumns, ...tax_cols ];
if ( post_type_info.opts.supports.includes('comments') ) {
defaultColumns = [...defaultColumns,{key: 'comment_count', title: '评论', sort: 'comment_count'}]
}
defaultColumns = [...defaultColumns,{key: 'modified_time', title: '日期', sort: 'modified_time'}]
var post_list_columns = apply_filters(`manage_admin_${post_type}_postlist_columns`,defaultColumns);
return {
post_type_info,
post_taxonomies,
post_list_columns,
}
},
permission_callback: power=>power >= 6,
});
register_rest_route('nv','get-admin-post-list',{
methods: 'post',
callback(data,req) {
const {post_type} = data;
if (!post_type) {
return new NV_Error('参数错误');
}
//如果权限是贡献者,那么只能读取到自己的文章
var user = get_user_by_nonce(req.headers.nvnonce);
var currentUserPower = user.power || 0;
if (currentUserPower <= 6) {
data.author = user.id;
}
//读取这个post对应posttype所注册的所有taxonomy
var post_taxs = get_taxonomies(post_type);
//查询文章
//有文章状态,就查询。否则查询所有状态文章(默认是publish)
data.status = data.status || '';
//查询所有时间段(包括已计划发布的)
data.date_query = {};
var queried_posts = query_posts(data);
var gotted_users = {};
//处理数据,增加作者和分类信息
queried_posts.data.forEach(post=>{
delete post.content;
// 读取作者
if ( gotted_users[post.author] == undefined ) {
gotted_users[post.author] = get_user_by_id(post.author).name || "";
}
post.author_name = gotted_users[post.author];
// 读取分类
post.taxonomies = {};
post_taxs.forEach(tax=>{
post.taxonomies[tax.taxonomy] = nv_get_object_terms(post.id, tax.taxonomy).map(term=>term.name);
})
//填充自定义列内容
Object.assign(post, apply_filters(`manage_admin_${post_type}_postlist_data`,post) );
})
return queried_posts;
},
permission_callback: power=>power >= 6,
});
/*register_rest_route('nv','get-editor-blocks',{
methods: 'post',
callback(data,req) {
const {post_type} = data;
return get_editor_blocks(post_type);
},
permission_callback: power=>power >= 6,
});*/
register_rest_route('nv','get-block-urls',{
methods: 'post',
callback() {
return get_block_urls();
},
permission_callback: power=>power >= 6,
});