WordPress.org

Make WordPress Core

Ticket #18438: 18438-westi.diff

File 18438-westi.diff, 13.5 KB (added by westi, 4 years ago)

Updated version of combo 3 based on my changes so far to correct things while reviewing tests.

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