WordPress.org

Make WordPress Core

Changeset 20137


Ignore:
Timestamp:
03/07/12 17:02:22 (2 years ago)
Author:
westi
Message:

XML-RPC: Initial implementation of Taxonomy and Term APIs.

Implements: wp.newTerm, wp.editTerm, wp.deleteTerm, wp.getTerm, wp.getTerms, wp.getTaxonomy and wp.getTaxonomies

See: #18438, #18439, #18440, #18441, #18442, #18443, and #18444 props maxcutler, markoheijnen and nprasath002.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/class-wp-xmlrpc-server.php

    r20075 r20137  
    4242            'wp.getPost'            => 'this:wp_getPost', 
    4343            'wp.getPosts'           => 'this:wp_getPosts', 
     44            'wp.newTerm'            => 'this:wp_newTerm', 
     45            'wp.editTerm'           => 'this:wp_editTerm', 
     46            'wp.deleteTerm'         => 'this:wp_deleteTerm', 
     47            'wp.getTerm'            => 'this:wp_getTerm', 
     48            'wp.getTerms'           => 'this:wp_getTerms', 
     49            'wp.getTaxonomy'        => 'this:wp_getTaxonomy', 
     50            'wp.getTaxonomies'      => 'this:wp_getTaxonomies', 
    4451            'wp.getPage'            => 'this:wp_getPage', 
    4552            'wp.getPages'           => 'this:wp_getPages', 
     
    478485 
    479486    /** 
     487     * Prepares taxonomy data for return in an XML-RPC object. 
     488     * 
     489     * @access protected 
     490    .* 
     491     * @param array|object $taxonomy The unprepared taxonomy data 
     492     * @return array The prepared taxonomy data 
     493     */ 
     494    protected function _prepare_taxonomy( $taxonomy ) { 
     495        $_taxonomy = (array) $taxonomy; 
     496 
     497        unset( $_taxonomy['update_count_callback'] ); 
     498 
     499        return apply_filters( 'xmlrpc__prepare_taxonomy', $_taxonomy, $taxonomy ); 
     500    } 
     501 
     502    /** 
     503     * Prepares term data for return in an XML-RPC object. 
     504     * 
     505     * @access protected 
     506    .* 
     507     * @param array|object $term The unprepared term data 
     508     * @return array The prepared term data 
     509     */ 
     510    protected function _prepare_term( $term ) { 
     511        $_term = $term; 
     512        if ( ! is_array( $_term) ) 
     513            $_term = get_object_vars( $_term ); 
     514 
     515        return apply_filters( 'xmlrpc__prepare_term', $_term, $term ); 
     516    } 
     517 
     518    /** 
    480519     * Prepares post data for return in an XML-RPC object. 
    481520     * 
    482      * @access private 
     521     * @access protected 
    483522     * 
    484523     * @param array $post The unprepared post data 
     
    486525     * @return array The prepared post data 
    487526     */ 
    488     function _prepare_post( $post, $fields ) { 
     527    protected function _prepare_post( $post, $fields ) { 
    489528        // holds the data for this post. built up based on $fields 
    490529        $_post = array( 'post_id' => $post['ID'] ); 
     
    534573            $_post['terms'] = array(); 
    535574            foreach ( $terms as $term ) { 
    536                 $_post['terms'][] = (array) $term; 
     575                $_post['terms'][] = $this->_prepare_term( $term ); 
    537576            } 
    538577        } 
     
    11071146 
    11081147            $struct[] = $this->_prepare_post( $post, $fields ); 
     1148        } 
     1149 
     1150        return $struct; 
     1151    } 
     1152 
     1153    /** 
     1154     * Create a new term. 
     1155     * 
     1156     * @uses wp_insert_term() 
     1157     * @param array $args Method parameters. Contains: 
     1158     *  - int     $blog_id 
     1159     *  - string  $username 
     1160     *  - string  $password 
     1161     *  - array   $content_struct 
     1162     *      The $content_struct must contain: 
     1163     *      - 'name' 
     1164     *      - 'taxonomy' 
     1165     *      Also, it can optionally contain: 
     1166     *      - 'parent' 
     1167     *      - 'description' 
     1168     *      - 'slug' 
     1169     * @return string term_id 
     1170     */ 
     1171    function wp_newTerm( $args ) { 
     1172        $this->escape( $args ); 
     1173 
     1174        $blog_id            = (int) $args[0]; 
     1175        $username           = $args[1]; 
     1176        $password           = $args[2]; 
     1177        $content_struct     = $args[3]; 
     1178 
     1179        if ( ! $user = $this->login( $username, $password ) ) 
     1180            return $this->error; 
     1181 
     1182        do_action( 'xmlrpc_call', 'wp.newTerm' ); 
     1183 
     1184        if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
     1185            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1186 
     1187        $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
     1188 
     1189        if ( ! current_user_can( $taxonomy->cap->manage_terms ) ) 
     1190            return new IXR_Error( 401, __( 'You are not allowed to create terms in this taxonomy.' ) ); 
     1191 
     1192        $taxonomy = (array) $taxonomy; 
     1193 
     1194        // hold the data of the term 
     1195        $term_data = array(); 
     1196 
     1197        $term_data['name'] = trim( $content_struct['name'] ); 
     1198        if ( empty( $term_data['name'] ) ) 
     1199            return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
     1200 
     1201        if ( isset( $content_struct['parent'] ) ) { 
     1202            if ( ! $taxonomy['hierarchical'] ) 
     1203                return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) ); 
     1204 
     1205            $parent_term_id = (int) $content_struct['parent']; 
     1206            $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
     1207 
     1208            if ( is_wp_error( $parent_term ) ) 
     1209                return new IXR_Error( 500, $parent_term->get_error_message() ); 
     1210 
     1211            if ( ! $parent_term ) 
     1212                return new IXR_Error( 403, __( 'Parent term does not exist.' ) ); 
     1213 
     1214            $term_data['parent'] = $content_struct['parent']; 
     1215        } 
     1216 
     1217        if ( isset( $content_struct['description'] ) ) 
     1218            $term_data['description'] = $content_struct['description']; 
     1219 
     1220        if ( isset( $content_struct['slug'] ) ) 
     1221            $term_data['slug'] = $content_struct['slug']; 
     1222 
     1223        $term = wp_insert_term( $term_data['name'] , $taxonomy['name'] , $term_data ); 
     1224 
     1225        if ( is_wp_error( $term ) ) 
     1226            return new IXR_Error( 500, $term->get_error_message() ); 
     1227 
     1228        if ( ! $term ) 
     1229            return new IXR_Error( 500, __( 'Sorry, your term could not be created. Something wrong happened.' ) ); 
     1230 
     1231        return strval( $term['term_id'] ); 
     1232    } 
     1233 
     1234    /** 
     1235     * Edit a term. 
     1236     * 
     1237     * @uses wp_update_term() 
     1238     * @param array $args Method parameters. Contains: 
     1239     *  - int     $blog_id 
     1240     *  - string  $username 
     1241     *  - string  $password 
     1242     *  - string  $term_id 
     1243     *  - array   $content_struct 
     1244     *      The $content_struct must contain: 
     1245     *      - 'taxonomy' 
     1246     *      Also, it can optionally contain: 
     1247     *      - 'name' 
     1248     *      - 'parent' 
     1249     *      - 'description' 
     1250     *      - 'slug' 
     1251     * @return bool True, on success. 
     1252     */ 
     1253    function wp_editTerm( $args ) { 
     1254        $this->escape( $args ); 
     1255 
     1256        $blog_id            = (int) $args[0]; 
     1257        $username           = $args[1]; 
     1258        $password           = $args[2]; 
     1259        $term_id            = (int) $args[3]; 
     1260        $content_struct     = $args[4]; 
     1261 
     1262        if ( ! $user = $this->login( $username, $password ) ) 
     1263            return $this->error; 
     1264 
     1265        do_action( 'xmlrpc_call', 'wp.editTerm' ); 
     1266 
     1267        if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
     1268            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1269 
     1270        $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
     1271 
     1272        if ( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
     1273            return new IXR_Error( 401, __( 'You are not allowed to edit terms in this taxonomy.' ) ); 
     1274 
     1275        $taxonomy = (array) $taxonomy; 
     1276 
     1277        // hold the data of the term 
     1278        $term_data = array(); 
     1279 
     1280        $term = get_term( $term_id , $content_struct['taxonomy'] ); 
     1281 
     1282        if ( is_wp_error( $term ) ) 
     1283            return new IXR_Error( 500, $term->get_error_message() ); 
     1284 
     1285        if ( ! $term ) 
     1286            return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     1287 
     1288        if ( isset( $content_struct['name'] ) ) { 
     1289            $term_data['name'] = trim( $content_struct['name'] ); 
     1290 
     1291            if ( empty( $term_data['name'] ) ) 
     1292                return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
     1293        } 
     1294 
     1295        if ( isset( $content_struct['parent'] ) ) { 
     1296            if ( ! $taxonomy['hierarchical'] ) 
     1297                return new IXR_Error( 403, __( "This taxonomy is not hierarchical so you can't set a parent." ) ); 
     1298 
     1299            $parent_term_id = (int) $content_struct['parent']; 
     1300            $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
     1301 
     1302            if ( is_wp_error( $parent_term ) ) 
     1303                return new IXR_Error( 500, $parent_term->get_error_message() ); 
     1304 
     1305            if ( ! $parent_term ) 
     1306                return new IXR_Error( 403, __( 'Parent term does not exist.' ) ); 
     1307 
     1308            $term_data['parent'] = $content_struct['parent']; 
     1309        } 
     1310 
     1311        if ( isset( $content_struct['description'] ) ) 
     1312            $term_data['description'] = $content_struct['description']; 
     1313 
     1314        if ( isset( $content_struct['slug'] ) ) 
     1315            $term_data['slug'] = $content_struct['slug']; 
     1316 
     1317        $term = wp_update_term( $term_id , $taxonomy['name'] , $term_data ); 
     1318 
     1319        if ( is_wp_error( $term ) ) 
     1320            return new IXR_Error( 500, $term->get_error_message() ); 
     1321 
     1322        if ( ! $term ) 
     1323            return new IXR_Error( 500, __( 'Sorry, editing the term failed.' ) ); 
     1324 
     1325        return true; 
     1326    } 
     1327 
     1328    /** 
     1329     * Delete a term. 
     1330     * 
     1331     * @uses wp_delete_term() 
     1332     * @param array $args Method parameters. Contains: 
     1333     *  - int     $blog_id 
     1334     *  - string  $username 
     1335     *  - string  $password 
     1336     *  - string  $taxnomy_name 
     1337     *  - string     $term_id 
     1338     * @return boolean|IXR_Error If it suceeded true else a reason why not 
     1339     */ 
     1340    function wp_deleteTerm( $args ) { 
     1341        $this->escape( $args ); 
     1342 
     1343        $blog_id            = (int) $args[0]; 
     1344        $username           = $args[1]; 
     1345        $password           = $args[2]; 
     1346        $taxonomy_name      = $args[3]; 
     1347        $term_id            = (int) $args[4]; 
     1348 
     1349        if ( ! $user = $this->login( $username, $password ) ) 
     1350            return $this->error; 
     1351 
     1352        do_action( 'xmlrpc_call', 'wp.deleteTerm' ); 
     1353 
     1354        if ( ! taxonomy_exists( $taxonomy_name ) ) 
     1355            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1356 
     1357        $taxonomy = get_taxonomy( $taxonomy_name ); 
     1358 
     1359        if ( ! current_user_can( $taxonomy->cap->delete_terms ) ) 
     1360            return new IXR_Error( 401, __( 'You are not allowed to delete terms in this taxonomy.' ) ); 
     1361 
     1362        $term = get_term( $term_id, $taxonomy_name ); 
     1363 
     1364        if ( is_wp_error( $term ) ) 
     1365            return new IXR_Error( 500, $term->get_error_message() ); 
     1366 
     1367        if ( ! $term ) 
     1368            return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     1369 
     1370        $result = wp_delete_term( $term_id, $taxonomy_name ); 
     1371 
     1372        if ( is_wp_error( $result ) ) 
     1373            return new IXR_Error( 500, $term->get_error_message() ); 
     1374 
     1375        if ( ! $result ) 
     1376            return new IXR_Error( 500, __( 'Sorry, deleting the term failed.' ) ); 
     1377 
     1378        return $result; 
     1379    } 
     1380 
     1381    /** 
     1382     * Retrieve a term. 
     1383     * 
     1384     * @uses get_term() 
     1385     * @param array $args Method parameters. Contains: 
     1386     *  - int     $blog_id 
     1387     *  - string  $username 
     1388     *  - string  $password 
     1389     *  - string  $taxonomy_name 
     1390     *  - string  $term_id 
     1391     * @return array contains: 
     1392     *  - 'term_id' 
     1393     *  - 'name' 
     1394     *  - 'slug' 
     1395     *  - 'term_group' 
     1396     *  - 'term_taxonomy_id' 
     1397     *  - 'taxonomy' 
     1398     *  - 'description' 
     1399     *  - 'parent' 
     1400     *  - 'count' 
     1401     */ 
     1402    function wp_getTerm( $args ) { 
     1403        $this->escape( $args ); 
     1404 
     1405        $blog_id            = (int) $args[0]; 
     1406        $username           = $args[1]; 
     1407        $password           = $args[2]; 
     1408        $taxonomy_name      = $args[3]; 
     1409        $term_id            = (int) $args[4]; 
     1410 
     1411        if ( ! $user = $this->login( $username, $password ) ) 
     1412            return $this->error; 
     1413 
     1414        do_action( 'xmlrpc_call', 'wp.getTerm' ); 
     1415 
     1416        if ( ! taxonomy_exists( $taxonomy_name ) ) 
     1417            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1418 
     1419        $taxonomy = get_taxonomy( $taxonomy_name ); 
     1420 
     1421        if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     1422            return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
     1423 
     1424        $term = get_term( $term_id , $taxonomy_name, ARRAY_A ); 
     1425 
     1426        if ( is_wp_error( $term ) ) 
     1427            return new IXR_Error( 500, $term->get_error_message() ); 
     1428 
     1429        if ( ! $term ) 
     1430            return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     1431 
     1432        return $this->_prepare_term( $term ); 
     1433    } 
     1434 
     1435    /** 
     1436     * Retrieve all terms for a taxonomy. 
     1437     * 
     1438     * The optional $filter parameter modifies the query used to retrieve terms. 
     1439     * Accepted keys are 'number', 'offset', 'orderby', 'order', 'hide_empty', and 'search'. 
     1440     * 
     1441     * @uses get_terms() 
     1442     * @param array $args Method parameters. Contains: 
     1443     *  - int     $blog_id 
     1444     *  - string  $username 
     1445     *  - string  $password 
     1446     *  - string  $taxonomy_name 
     1447     *  - array   $filter optional 
     1448     * @return array terms 
     1449     */ 
     1450    function wp_getTerms( $args ) { 
     1451        $this->escape( $args ); 
     1452 
     1453        $blog_id        = (int) $args[0]; 
     1454        $username       = $args[1]; 
     1455        $password       = $args[2]; 
     1456        $taxonomy_name  = $args[3]; 
     1457        $filter         = isset( $args[4] ) ? $args[4] : array(); 
     1458 
     1459        if ( ! $user = $this->login( $username, $password ) ) 
     1460            return $this->error; 
     1461 
     1462        do_action( 'xmlrpc_call', 'wp.getTerms' ); 
     1463 
     1464        if ( ! taxonomy_exists( $taxonomy_name ) ) 
     1465            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1466 
     1467        $taxonomy = get_taxonomy( $taxonomy_name ); 
     1468 
     1469        if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     1470            return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
     1471 
     1472        $query = array(); 
     1473 
     1474        if ( isset( $filter['number'] ) ) 
     1475            $query['number'] = absint( $filter['number'] ); 
     1476 
     1477        if ( isset( $filter['offset'] ) ) 
     1478            $query['offset'] = absint( $filter['offset'] ); 
     1479 
     1480        if ( isset( $filter['orderby'] ) ) { 
     1481            $query['orderby'] = $filter['orderby']; 
     1482 
     1483            if ( isset( $filter['order'] ) ) 
     1484                $query['order'] = $filter['order']; 
     1485        } 
     1486 
     1487        if ( isset( $filter['hide_empty'] ) ) 
     1488            $query['hide_empty'] = $filter['hide_empty']; 
     1489        else 
     1490            $query['get'] = 'all'; 
     1491 
     1492        if ( isset( $filter['search'] ) ) 
     1493            $query['search'] = $filter['search']; 
     1494 
     1495        $terms = get_terms( $taxonomy_name, $query ); 
     1496 
     1497        if ( is_wp_error( $terms ) ) 
     1498            return new IXR_Error( 500, $terms->get_error_message() ); 
     1499 
     1500        $struct = array(); 
     1501 
     1502        foreach ( $terms as $term ) { 
     1503            $struct[] = $this->_prepare_term( $term ); 
     1504        } 
     1505 
     1506        return $struct; 
     1507    } 
     1508 
     1509    /** 
     1510     * Retrieve a taxonomy. 
     1511     * 
     1512     * @uses get_taxonomy() 
     1513     * @param array $args Method parameters. Contains: 
     1514     *  - int     $blog_id 
     1515     *  - string  $username 
     1516     *  - string  $password 
     1517     *  - string  $taxonomy_name 
     1518     * @return array (@see get_taxonomy()) 
     1519     */ 
     1520    function wp_getTaxonomy( $args ) { 
     1521        $this->escape( $args ); 
     1522 
     1523        $blog_id        = (int) $args[0]; 
     1524        $username       = $args[1]; 
     1525        $password       = $args[2]; 
     1526        $taxonomy_name  = $args[3]; 
     1527 
     1528        if ( ! $user = $this->login( $username, $password ) ) 
     1529            return $this->error; 
     1530 
     1531        do_action( 'xmlrpc_call', 'wp.getTaxonomy' ); 
     1532 
     1533        if ( ! taxonomy_exists( $taxonomy_name ) ) 
     1534            return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     1535 
     1536        $taxonomy = get_taxonomy( $taxonomy_name ); 
     1537 
     1538        if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     1539            return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
     1540 
     1541        return $this->_prepare_taxonomy( $taxonomy ); 
     1542    } 
     1543 
     1544    /** 
     1545     * Retrieve all taxonomies. 
     1546     * 
     1547     * @uses get_taxonomies() 
     1548     * @param array $args Method parameters. Contains: 
     1549     *  - int     $blog_id 
     1550     *  - string  $username 
     1551     *  - string  $password 
     1552     * @return array taxonomies 
     1553     */ 
     1554    function wp_getTaxonomies( $args ) { 
     1555        $this->escape( $args ); 
     1556 
     1557        $blog_id            = (int) $args[0]; 
     1558        $username           = $args[1]; 
     1559        $password           = $args[2]; 
     1560 
     1561        if ( ! $user = $this->login( $username, $password ) ) 
     1562            return $this->error; 
     1563 
     1564        do_action( 'xmlrpc_call', 'wp.getTaxonomies' ); 
     1565 
     1566        $taxonomies = get_taxonomies( array(), 'objects' ); 
     1567 
     1568        // holds all the taxonomy data 
     1569        $struct = array(); 
     1570 
     1571        foreach ( $taxonomies as $taxonomy ) { 
     1572            // capability check for post_types 
     1573            if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     1574                continue; 
     1575 
     1576            $struct[] = $this->_prepare_taxonomy( $taxonomy ); 
    11091577        } 
    11101578 
Note: See TracChangeset for help on using the changeset viewer.