WordPress.org

Make WordPress Core

Ticket #18438: taxes.combo.5.patch

File taxes.combo.5.patch, 14.4 KB (added by maxcutler, 6 years ago)
  • wp-includes/class-wp-xmlrpc-server.php

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