WordPress.org

Make WordPress Core

Ticket #18438: taxes.combo.2.patch

File taxes.combo.2.patch, 13.0 KB (added by maxcutler, 6 years ago)

Refreshed patch after other recent changes.

  • 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',
     
    452459        }
    453460
    454461        /**
     462         * Prepares taxonomy data for return in an XML-RPC object.
     463         *
     464         * @param array|object $taxonomy The unprepared taxonomy data
     465         * @return array The prepared taxonomy data
     466         */
     467        function prepare_taxonomy( $taxonomy ) {
     468                $_taxonomy = (array) $taxonomy;
     469
     470                unset( $_taxonomy['update_count_callback'] );
     471
     472                return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy );
     473        }
     474
     475        /**
     476         * Prepares term data for return in an XML-RPC object.
     477         *
     478         * @param array $term The unprepared term data
     479         * @return array The prepared term data
     480         */
     481        function prepare_term( $term ) {
     482                $_term = (array) $term;
     483
     484                return apply_filters( 'xmlrpc_prepare_term', $_term, $term );
     485        }
     486
     487        /**
    455488         * Prepares post data for return in an XML-RPC object.
    456489         *
    457490         * @access private
     
    508541                        $terms = wp_get_object_terms( $post['ID'], $post_type_taxonomies );
    509542                        $_post['terms'] = array();
    510543                        foreach ( $terms as $term ) {
    511                                 $_post['terms'][] = (array) $term;
     544                                $_post['terms'][] = $this->prepare_term( $term );
    512545                        }
    513546                }
    514547
     
    10821115        }
    10831116
    10841117        /**
     1118         * Create a new term.
     1119         *
     1120         * @uses wp_insert_term()
     1121         * @param array $args Method parameters. Contains:
     1122         *  - int     $blog_id
     1123         *  - string  $username
     1124         *  - string  $password
     1125         *  - array   $content_struct
     1126         *      The $content_struct must contain:
     1127         *      - 'name'
     1128         *      - 'taxonomy'
     1129         *      Also, it can optionally contain:
     1130         *      - 'parent'
     1131         *      - 'description'
     1132         *      - 'slug'
     1133         * @return int term_id
     1134         */
     1135        function wp_newTerm( $args ) {
     1136                $this->escape( $args );
     1137
     1138                $blog_id            = (int) $args[0];
     1139                $username           = $args[1];
     1140                $password           = $args[2];
     1141                $content_struct     = $args[3];
     1142
     1143                if ( ! $user = $this->login( $username, $password ) )
     1144                        return $this->error;
     1145
     1146                do_action( 'xmlrpc_call', 'wp.newTerm' );
     1147
     1148                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) )
     1149                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) );
     1150
     1151                $taxonomy = get_taxonomy( $content_struct['taxonomy'] );
     1152
     1153                if ( ! current_user_can( $taxonomy->cap->manage_terms ) )
     1154                        return new IXR_Error( 401, __( 'You are not allowed to create terms in this taxonomy.' ) );
     1155
     1156                $taxonomy = (array) $taxonomy;
     1157
     1158                // hold the data of the term
     1159                $term_data = array();
     1160
     1161                $term_data['name'] = trim( $content_struct['name'] );
     1162                if ( empty( $term_data['name'] ) )
     1163                        return new IXR_Error( 403, __( 'The term name cannot be empty.' ) );
     1164
     1165                if ( isset( $content_struct['parent'] ) ) {
     1166                        if ( ! $taxonomy['hierarchical'] )
     1167                                return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) );
     1168
     1169                        $parent_term_id = (int) $content_struct['parent'];
     1170                        $parent_term = get_term( $parent_term_id , $taxonomy['name'] );
     1171
     1172                        if ( is_wp_error( $parent_term ) )
     1173                                return new IXR_Error( 500, $parent_term->get_error_message() );
     1174
     1175                        if ( ! $parent_term )
     1176                                return new IXR_Error( 500, __( 'Parent term does not exist.' ) );
     1177
     1178                        $term_data['parent'] = $content_struct['parent'];
     1179                }
     1180
     1181                if ( isset( $content_struct['description'] ) )
     1182                        $term_data['description'] = $content_struct['description'];
     1183
     1184                if ( isset( $content_struct['slug'] ) )
     1185                        $term_data['slug'] = $content_struct['slug'];
     1186
     1187                $term = wp_insert_term( $term_data['name'] , $taxonomy['name'] , $term_data );
     1188
     1189                if ( is_wp_error( $term ) )
     1190                        return new IXR_Error( 500, $term->get_error_message() );
     1191
     1192                if ( ! $term )
     1193                        return new IXR_Error( 500, __( 'Sorry, your term could not be created. Something wrong happened.' ) );
     1194
     1195                return $term['term_id'];
     1196        }
     1197
     1198        /**
     1199         * Edit a term.
     1200         *
     1201         * @uses wp_update_term()
     1202         * @param array $args Method parameters. Contains:
     1203         *  - int     $blog_id
     1204         *  - string  $username
     1205         *  - string  $password
     1206         *  - int     $term_id
     1207         *  - array   $content_struct
     1208         *      The $content_struct must contain:
     1209         *      - 'taxonomy'
     1210         *      Also, it can optionally contain:
     1211         *      - 'name'
     1212         *      - 'parent'
     1213         *      - 'description'
     1214         *      - 'slug'
     1215         * @return bool True, on success.
     1216         */
     1217        function wp_editTerm( $args ) {
     1218                $this->escape( $args );
     1219
     1220                $blog_id            = (int) $args[0];
     1221                $username           = $args[1];
     1222                $password           = $args[2];
     1223                $term_id            = (int) $args[3];
     1224                $content_struct     = $args[4];
     1225
     1226                if ( ! $user = $this->login( $username, $password ) )
     1227                        return $this->error;
     1228
     1229                do_action( 'xmlrpc_call', 'wp.editTerm' );
     1230
     1231                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) )
     1232                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) );
     1233
     1234                $taxonomy = get_taxonomy( $content_struct['taxonomy'] );
     1235
     1236                if ( ! current_user_can( $taxonomy->cap->edit_terms ) )
     1237                        return new IXR_Error( 401, __( 'You are not allowed to edit terms in this taxonomy.' ) );
     1238
     1239                $taxonomy = (array) $taxonomy;
     1240
     1241                // hold the data of the term
     1242                $term_data = array();
     1243
     1244                $term = get_term( $term_id , $content_struct['taxonomy'] );
     1245
     1246                if ( is_wp_error( $term ) )
     1247                        return new IXR_Error( 500, $term->get_error_message() );
     1248
     1249                if ( ! $term )
     1250                        return new IXR_Error( 404, __( 'Invalid term ID.' ) );
     1251
     1252                if ( isset( $content_struct['name'] ) ) {
     1253                        $term_data['name'] = trim( $content_struct['name'] );
     1254
     1255                        if ( empty( $term_data['name'] ) )
     1256                                return new IXR_Error( 403, __( 'The term name cannot be empty.' ) );
     1257                }
     1258
     1259                if ( isset( $content_struct['parent'] ) ) {
     1260                        if ( ! $taxonomy['hierarchical'] )
     1261                                return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) );
     1262
     1263                        $parent_term_id = (int) $content_struct['parent'];
     1264                        $parent_term = get_term( $parent_term_id , $taxonomy['name'] );
     1265
     1266                        if ( is_wp_error( $parent_term ) )
     1267                                return new IXR_Error( 500, $term->get_error_message() );
     1268
     1269                        if ( ! $parent_term )
     1270                                return new IXR_Error( 403, __( 'Invalid parent term ID.' ) );
     1271
     1272                        $term_data['parent'] = $content_struct['parent'];
     1273                }
     1274
     1275                if ( isset( $content_struct['description'] ) )
     1276                        $term_data['description'] = $content_struct['description'];
     1277
     1278                if ( isset( $content_struct['slug'] ) )
     1279                        $term_data['slug'] = $content_struct['slug'];
     1280
     1281                $term = wp_update_term( $term_id , $taxonomy['name'] , $term_data );
     1282
     1283                if ( is_wp_error( $term ) )
     1284                        return new IXR_Error( 500, $term->get_error_message() );
     1285
     1286                if ( ! $term )
     1287                        return new IXR_Error( 500, __( 'Sorry, editing the term failed.' ) );
     1288
     1289                return true;
     1290        }
     1291
     1292        /**
     1293         * Delete a term.
     1294         *
     1295         * @uses wp_delete_term()
     1296         * @param array $args Method parameters. Contains:
     1297         *  - int     $blog_id
     1298         *  - string  $username
     1299         *  - string  $password
     1300         *  - string  $taxnomy_name
     1301         *  - int     $term_id
     1302         * @return boolean true
     1303         */
     1304        function wp_deleteTerm( $args ) {
     1305                $this->escape( $args );
     1306
     1307                $blog_id            = (int) $args[0];
     1308                $username           = $args[1];
     1309                $password           = $args[2];
     1310                $taxonomy_name      = $args[3];
     1311                $term_id            = (int) $args[4];
     1312
     1313                if ( ! $user = $this->login( $username, $password ) )
     1314                        return $this->error;
     1315
     1316                do_action( 'xmlrpc_call', 'wp.editTerm' );
     1317
     1318                if ( ! taxonomy_exists( $taxonomy_name ) )
     1319                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) );
     1320
     1321                $taxonomy = get_taxonomy( $taxonomy_name );
     1322
     1323                if ( ! current_user_can( $taxonomy->cap->delete_terms ) )
     1324                        return new IXR_Error( 401, __( 'You are not allowed to delete terms in this taxonomy.' ) );
     1325
     1326                $term = get_term( $term_id, $taxonomy_name );
     1327
     1328                if ( is_wp_error( $term ) )
     1329                        return new IXR_Error( 500, $term->get_error_message() );
     1330
     1331                if ( ! $term )
     1332                        return new IXR_Error( 404, __( 'Invalid term ID.' ) );
     1333
     1334                $result = wp_delete_term( $term_id, $taxonomy_name );
     1335
     1336                if ( is_wp_error( $result ) )
     1337                        return new IXR_Error( 500, $term->get_error_message() );
     1338
     1339                if ( ! $result )
     1340                        return new IXR_Error( 500, __( 'Sorry, deleting the term failed.' ) );
     1341
     1342                return $result;
     1343        }
     1344
     1345        /**
     1346         * Retrieve a term.
     1347         *
     1348         * @uses get_term()
     1349         * @param array $args Method parameters. Contains:
     1350         *  - int     $blog_id
     1351         *  - string  $username
     1352         *  - string  $password
     1353         *  - string  $taxonomy_name
     1354         *  - int     $term_id
     1355         * @return array contains:
     1356         *  - 'term_id'
     1357         *  - 'name'
     1358         *  - 'slug'
     1359         *  - 'term_group'
     1360         *  - 'term_taxonomy_id'
     1361         *  - 'taxonomy'
     1362         *  - 'description'
     1363         *  - 'parent'
     1364         *  - 'count'
     1365         */
     1366        function wp_getTerm( $args ) {
     1367                $this->escape( $args );
     1368
     1369                $blog_id            = (int) $args[0];
     1370                $username           = $args[1];
     1371                $password           = $args[2];
     1372                $taxonomy_name      = $args[3];
     1373                $term_id            = (int) $args[4];
     1374
     1375                if ( ! $user = $this->login( $username, $password ) )
     1376                        return $this->error;
     1377
     1378                do_action( 'xmlrpc_call', 'wp.getTerm' );
     1379
     1380                if ( ! taxonomy_exists( $taxonomy_name ) )
     1381                        return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) );
     1382
     1383                $taxonomy = get_taxonomy( $taxonomy_name );
     1384
     1385                if ( ! current_user_can( $taxonomy->cap->assign_terms ) )
     1386                        return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) );
     1387
     1388                $term = get_term( $term_id , $taxonomy_name );
     1389
     1390                if ( is_wp_error( $term ) )
     1391                        return new IXR_Error( 500, $term->get_error_message() );
     1392
     1393                if ( ! $term )
     1394                        return new IXR_Error( 404, __( 'Invalid term ID.' ) );
     1395
     1396                return $this->prepare_term( $term );
     1397        }
     1398
     1399        /**
     1400         * Retrieve all terms for a taxonomy.
     1401         *
     1402         * @uses get_terms()
     1403         * @param array $args Method parameters. Contains:
     1404         *  - int     $blog_id
     1405         *  - string  $username
     1406         *  - string  $password
     1407         *  - string   $taxonomy_name
     1408         * @return array terms
     1409         */
     1410        function wp_getTerms( $args ) {
     1411                $this->escape( $args );
     1412
     1413                $blog_id        = (int) $args[0];
     1414                $username       = $args[1];
     1415                $password       = $args[2];
     1416                $taxonomy_name  = $args[3];
     1417
     1418                if ( ! $user = $this->login( $username, $password ) )
     1419                        return $this->error;
     1420
     1421                do_action( 'xmlrpc_call', 'wp.getTerms' );
     1422
     1423                if ( ! taxonomy_exists( $taxonomy_name ) )
     1424                        return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) );
     1425
     1426                $taxonomy = get_taxonomy( $taxonomy_name );
     1427
     1428                if ( ! current_user_can( $taxonomy->cap->assign_terms ) )
     1429                        return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) );
     1430
     1431                $terms = get_terms( $taxonomy_name , array( 'get' => 'all' ) );
     1432
     1433                if ( is_wp_error( $terms ) )
     1434                        return new IXR_Error( 500, $terms->get_error_message() );
     1435
     1436                $struct = array();
     1437
     1438                foreach ( $terms as $term ) {
     1439                        $struct[] = $this->prepare_term( $term );
     1440                }
     1441
     1442                return $struct;
     1443        }
     1444
     1445        /**
     1446         * Retrieve a taxonomy.
     1447         *
     1448         * @uses get_taxonomy()
     1449         * @param array $args Method parameters. Contains:
     1450         *  - int     $blog_id
     1451         *  - string  $username
     1452         *  - string  $password
     1453         *  - string  $taxonomy_name
     1454         * @return array (@see get_taxonomy())
     1455         */
     1456        function wp_getTaxonomy( $args ) {
     1457                $this->escape( $args );
     1458
     1459                $blog_id        = (int) $args[0];
     1460                $username       = $args[1];
     1461                $password       = $args[2];
     1462                $taxonomy_name  = $args[3];
     1463
     1464                if ( ! $user = $this->login( $username, $password ) )
     1465                        return $this->error;
     1466
     1467                do_action( 'xmlrpc_call', 'wp.getTaxonomy' );
     1468
     1469                if ( ! taxonomy_exists( $taxonomy_name ) )
     1470                        return new IXR_Error( 403, __( 'The taxonomy type specified is not valid' ) );
     1471
     1472                $taxonomy = get_taxonomy( $taxonomy_name );
     1473
     1474                if ( ! current_user_can( $taxonomy->cap->edit_terms ) )
     1475                        return new IXR_Error( 401, __( 'Sorry, You are not allowed to edit this post type' ) );
     1476
     1477                return $this->prepare_taxonomy( $taxonomy );
     1478        }
     1479
     1480        /**
     1481         * Retrieve all taxonomies.
     1482         *
     1483         * @uses get_taxonomies()
     1484         * @param array $args Method parameters. Contains:
     1485         *  - int     $blog_id
     1486         *  - string  $username
     1487         *  - string  $password
     1488         * @return array taxonomies
     1489         */
     1490        function wp_getTaxonomies( $args ) {
     1491                $this->escape( $args );
     1492
     1493                $blog_id            = (int) $args[0];
     1494                $username           = $args[1];
     1495                $password           = $args[2];
     1496
     1497                if ( ! $user = $this->login( $username, $password ) )
     1498                        return $this->error;
     1499
     1500                do_action( 'xmlrpc_call', 'wp.getTaxonomies' );
     1501
     1502                $taxonomies = get_taxonomies( '', 'objects' );
     1503
     1504                // holds all the taxonomy data
     1505                $struct = array();
     1506
     1507                foreach ( $taxonomies as $taxonomy ) {
     1508                        // capability check for post_types
     1509                        if ( ! current_user_can( $taxonomy->cap->edit_terms ) )
     1510                                continue;
     1511
     1512                        $struct[] = $this->prepare_taxonomy( $taxonomy );
     1513                }
     1514
     1515                return $struct;
     1516        }
     1517
     1518        /**
    10851519         * Retrieve page.
    10861520         *
    10871521         * @since 2.2.0