| | 1716 | /** |
| | 1717 | * Create a new post for any registered post type. |
| | 1718 | * |
| | 1719 | * The 'content_struct' argument can contain: |
| | 1720 | * - post_type (default: 'post') |
| | 1721 | * - post_status (default: 'draft') |
| | 1722 | * - post_title |
| | 1723 | * - post_author |
| | 1724 | * - post_exerpt |
| | 1725 | * - post_content |
| | 1726 | * - post_date_gmt | post_date |
| | 1727 | * - post_format |
| | 1728 | * - post_password |
| | 1729 | * - comment_status - can be 'open' | 'closed' |
| | 1730 | * - ping_status - can be 'open' | 'closed' |
| | 1731 | * - sticky |
| | 1732 | * - custom_fields - array, with each element containing 'key' and 'value' |
| | 1733 | * - terms - array, with taxonomy names as keys and arrays of term IDs as values |
| | 1734 | * - terms_names - array, with taxonomy names as keys and arrays of term names as values |
| | 1735 | * - enclosure |
| | 1736 | * - any other fields supported by wp_insert_post() |
| | 1737 | * |
| | 1738 | * @since 3.4 |
| | 1739 | * @uses wp_insert_post() |
| | 1740 | * @uses do_action() Calls 'xmlrpc_call' passing 'wp.newPost' |
| | 1741 | * @uses apply_filters() Calls 'xmlrpc_wp_newPost_post_data' passing $post_data, $content_struct prior to calling wp_insert_post() |
| | 1742 | * |
| | 1743 | * @param array $args Method parameters. Contains: |
| | 1744 | * - blog_id |
| | 1745 | * - username |
| | 1746 | * - password |
| | 1747 | * - content_struct |
| | 1748 | * @return string post_id |
| | 1749 | */ |
| | 1750 | function wp_newPost( $args ) { |
| | 1751 | $this->escape( $args ); |
| | 1752 | |
| | 1753 | $blog_id = (int) $args[0]; // we will support this in the near future |
| | 1754 | $username = $args[1]; |
| | 1755 | $password = $args[2]; |
| | 1756 | $content_struct = $args[3]; |
| | 1757 | |
| | 1758 | if ( ! $user = $this->login($username, $password) ) |
| | 1759 | return $this->error; |
| | 1760 | |
| | 1761 | do_action( 'xmlrpc_call', 'wp.newPost' ); |
| | 1762 | |
| | 1763 | return $this->_wp_insertPost( $user, $content_struct ); |
| | 1764 | } |
| | 1765 | |
| | 1766 | /* |
| | 1767 | * Helper method for wp_newPost and wp_editPost, containing shared logic. |
| | 1768 | */ |
| | 1769 | function _wp_insertPost( $user, $content_struct ) { |
| | 1770 | $defaults = array( 'post_status' => 'draft', 'post_type' => 'post', 'post_author' => 0, |
| | 1771 | 'post_password' => '', 'post_excerpt' => '', 'post_content' => '', 'post_title' => '', 'sticky' => 0 ); |
| | 1772 | |
| | 1773 | $post_data = wp_parse_args( $content_struct, $defaults ); |
| | 1774 | |
| | 1775 | $post_type = get_post_type_object( $post_data['post_type'] ); |
| | 1776 | if( ! ( (bool)$post_type ) ) |
| | 1777 | return new IXR_Error( 403, __( 'Invalid post type' ) ); |
| | 1778 | |
| | 1779 | if( ! current_user_can( $post_type->cap->edit_posts ) ) |
| | 1780 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to post on this site.' ) ); |
| | 1781 | |
| | 1782 | switch ( $post_data['post_status'] ) { |
| | 1783 | case 'draft': |
| | 1784 | case 'pending': |
| | 1785 | break; |
| | 1786 | case 'private': |
| | 1787 | if( ! current_user_can( $post_type->cap->publish_posts ) ) |
| | 1788 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to create private posts in this post type' )); |
| | 1789 | break; |
| | 1790 | case 'publish': |
| | 1791 | case 'future': |
| | 1792 | if( ! current_user_can( $post_type->cap->publish_posts ) ) |
| | 1793 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to publish posts in this post type' )); |
| | 1794 | break; |
| | 1795 | default: |
| | 1796 | $post_data['post_status'] = 'draft'; |
| | 1797 | break; |
| | 1798 | } |
| | 1799 | |
| | 1800 | if ( ! empty( $post_data['post_password'] ) && ! current_user_can( $post_type->cap->publish_posts ) ) |
| | 1801 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to create password protected posts in this post type' ) ); |
| | 1802 | |
| | 1803 | |
| | 1804 | $post_data['post_author'] = absint( $post_data['post_author'] ); |
| | 1805 | if( ! empty( $post_data['post_author'] ) && $post_data['post_author'] != $user->ID ) { |
| | 1806 | if( ! current_user_can( $post_type->cap->edit_others_posts ) ) |
| | 1807 | return new IXR_Error( 401, __( 'You are not allowed to create posts as this user.' ) ); |
| | 1808 | |
| | 1809 | $author = get_userdata( $post_data['post_author'] ); |
| | 1810 | |
| | 1811 | if( ! $author ) |
| | 1812 | return new IXR_Error( 404, __( 'Invalid author ID.' ) ); |
| | 1813 | } |
| | 1814 | else { |
| | 1815 | $post_data['post_author'] = $user->ID; |
| | 1816 | } |
| | 1817 | |
| | 1818 | if( isset( $post_data['comment_status'] ) ) |
| | 1819 | if( ! post_type_supports( $post_data['post_type'], 'comments' ) || ( $post_data['comment_status'] != 'open' && $post_data['comment_status'] != 'closed' ) ) |
| | 1820 | unset( $post_data['comment_status'] ); |
| | 1821 | |
| | 1822 | if( isset( $post_data['ping_status'] ) ) |
| | 1823 | if( ! post_type_supports( $post_data['post_type'], 'trackbacks' ) || ( $post_data['ping_status'] != 'open' && $post_data['ping_status'] != 'closed' ) ) |
| | 1824 | unset( $post_data['ping_status'] ); |
| | 1825 | |
| | 1826 | // Do some timestamp voodoo |
| | 1827 | if ( ! empty( $post_data['post_date_gmt'] ) ) |
| | 1828 | $dateCreated = str_replace( 'Z', '', $post_data['post_date_gmt']->getIso() ) . 'Z'; // We know this is supposed to be GMT, so we're going to slap that Z on there by force |
| | 1829 | elseif ( ! empty( $post_data['post_date']) ) |
| | 1830 | $dateCreated = $post_data['post_date']->getIso(); |
| | 1831 | |
| | 1832 | if ( ! empty( $dateCreated ) ) { |
| | 1833 | $post_data['post_date'] = get_date_from_gmt( iso8601_to_datetime( $dateCreated ) ); |
| | 1834 | $post_data['post_date_gmt'] = iso8601_to_datetime( $dateCreated, 'GMT' ); |
| | 1835 | } |
| | 1836 | |
| | 1837 | if ( ! isset( $post_data['ID'] ) ) { |
| | 1838 | $post_data['ID'] = get_default_post_to_edit( $post_data['post_type'], true )->ID; |
| | 1839 | } |
| | 1840 | $post_ID = $post_data['ID']; |
| | 1841 | |
| | 1842 | $sticky = $post_data['sticky'] ? true : false; |
| | 1843 | |
| | 1844 | if( $post_data['post_type'] == 'post' && $sticky == true ) { |
| | 1845 | if( ! current_user_can( $post_type->cap->edit_others_posts ) ) |
| | 1846 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to stick this post.' ) ); |
| | 1847 | |
| | 1848 | if( $post_data['post_status'] != 'publish' ) |
| | 1849 | return new IXR_Error( 401, __( 'Only published posts can be made sticky.' )); |
| | 1850 | |
| | 1851 | stick_post( $post_ID ); |
| | 1852 | } |
| | 1853 | |
| | 1854 | if( isset ( $post_data['custom_fields'] ) && post_type_supports( $post_data['post_type'], 'custom-fields' ) ) { |
| | 1855 | $this->set_custom_fields( $post_ID, $post_data['custom_fields'] ); |
| | 1856 | } |
| | 1857 | |
| | 1858 | if( isset( $post_data['terms'] ) || isset( $post_data['terms_names'] ) ) { |
| | 1859 | $post_type_taxonomies = get_object_taxonomies( $post_data['post_type'], 'objects' ); |
| | 1860 | |
| | 1861 | // accumulate term IDs from terms and terms_names |
| | 1862 | $terms = array(); |
| | 1863 | |
| | 1864 | // first validate the terms specified by ID |
| | 1865 | if( isset( $post_data['terms'] ) && is_array( $post_data['terms'] ) ) { |
| | 1866 | $taxonomies = array_keys( $post_data['terms'] ); |
| | 1867 | |
| | 1868 | // validating term ids |
| | 1869 | foreach ( $taxonomies as $taxonomy ) { |
| | 1870 | if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) ) |
| | 1871 | return new IXR_Error( 401, __( 'Sorry, one of the given taxonomy is not supported by the post type.' ) ); |
| | 1872 | |
| | 1873 | if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) ) |
| | 1874 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies' ) ); |
| | 1875 | |
| | 1876 | $term_ids = $post_data['terms'][$taxonomy]; |
| | 1877 | foreach ( $term_ids as $term_id ) { |
| | 1878 | $term = get_term_by( 'id', $term_id, $taxonomy ); |
| | 1879 | |
| | 1880 | if ( ! $term ) |
| | 1881 | return new IXR_Error( 403, __( 'Invalid term ID' ) ); |
| | 1882 | |
| | 1883 | $terms[$taxonomy][] = (int)$term_id; |
| | 1884 | } |
| | 1885 | } |
| | 1886 | } |
| | 1887 | |
| | 1888 | // now validate terms specified by name |
| | 1889 | if ( isset( $post_data['terms_names'] ) && is_array( $post_data['terms_names'] ) ) { |
| | 1890 | $taxonomies = array_keys( $post_data['terms_names'] ); |
| | 1891 | |
| | 1892 | foreach ( $taxonomies as $taxonomy ) { |
| | 1893 | if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) ) |
| | 1894 | return new IXR_Error( 401, __( 'Sorry, one of the given taxonomy is not supported by the post type.' ) ); |
| | 1895 | |
| | 1896 | if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) ) |
| | 1897 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) ); |
| | 1898 | |
| | 1899 | // for hierarchical taxonomies, we can't assign a term when multiple terms in the hierarchy share the same name |
| | 1900 | $ambiguous_terms = array(); |
| | 1901 | if( is_taxonomy_hierarchical( $taxonomy ) ) { |
| | 1902 | $tax_term_names = get_terms( $taxonomy, array( 'fields' => 'names', 'hide_empty' => false ) ); |
| | 1903 | |
| | 1904 | // count the number of terms with the same name |
| | 1905 | $tax_term_names_count = array_count_values( $tax_term_names ); |
| | 1906 | |
| | 1907 | // filter out non-ambiguous term names |
| | 1908 | $ambiguous_tax_term_counts = array_filter( $tax_term_names_count, function($count){ |
| | 1909 | return $count > 1; |
| | 1910 | } ); |
| | 1911 | |
| | 1912 | $ambiguous_terms = array_keys( $ambiguous_tax_term_counts ); |
| | 1913 | } |
| | 1914 | |
| | 1915 | $term_names = $post_data['terms_names'][$taxonomy]; |
| | 1916 | foreach ( $term_names as $term_name ) { |
| | 1917 | if ( in_array( $term_name, $ambiguous_terms ) ) |
| | 1918 | return new IXR_Error( 401, __( 'Ambiguous term name used in a hierarhical taxonomy. Please use term ID instead.' ) ); |
| | 1919 | |
| | 1920 | $term = get_term_by( 'name', $term_name, $taxonomy ); |
| | 1921 | |
| | 1922 | if ( ! $term ) { |
| | 1923 | // term doesn't exist, so check that the user is allowed to create new terms |
| | 1924 | if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->edit_terms ) ) |
| | 1925 | return new IXR_Error( 401, __( 'Sorry, you are not allowed to add a term to one of the given taxonomies.' ) ); |
| | 1926 | |
| | 1927 | // create the new term |
| | 1928 | $term_info = wp_insert_term( $term_name, $taxonomy ); |
| | 1929 | if ( is_wp_error( $term_info ) ) |
| | 1930 | return new IXR_Error( 500, $term_info->get_error_message() ); |
| | 1931 | |
| | 1932 | $terms[$taxonomy][] = (int)$term_info['term_id']; |
| | 1933 | } |
| | 1934 | else { |
| | 1935 | $terms[$taxonomy][] = (int)$term->term_id; |
| | 1936 | } |
| | 1937 | } |
| | 1938 | } |
| | 1939 | } |
| | 1940 | |
| | 1941 | $post_data['tax_input'] = $terms; |
| | 1942 | unset( $post_data['terms'] ); |
| | 1943 | unset( $post_data['terms_names'] ); |
| | 1944 | } |
| | 1945 | else { |
| | 1946 | // do not allow direct submission of 'tax_input', clients must use 'terms' and/or 'terms_names' |
| | 1947 | unset( $post_data['tax_input'] ); |
| | 1948 | } |
| | 1949 | |
| | 1950 | if( isset( $post_data['post_format'] ) ) { |
| | 1951 | $format = set_post_format( $post_ID, $post_data['post_format'] ); |
| | 1952 | |
| | 1953 | if ( is_wp_error( $format ) ) |
| | 1954 | return new IXR_Error( 500, $format->get_error_message() ); |
| | 1955 | |
| | 1956 | unset( $post_data['post_format'] ); |
| | 1957 | } |
| | 1958 | |
| | 1959 | // Handle enclosures |
| | 1960 | $enclosure = isset( $post_data['enclosure'] ) ? $post_data['enclosure'] : null; |
| | 1961 | $this->add_enclosure_if_new( $post_ID, $enclosure ); |
| | 1962 | |
| | 1963 | $this->attach_uploads( $post_ID, $post_data['post_content'] ); |
| | 1964 | |
| | 1965 | $post_data = apply_filters( 'xmlrpc_wp_insert_post_data', $post_data, $content_struct ); |
| | 1966 | |
| | 1967 | $post_ID = wp_insert_post( $post_data, true ); |
| | 1968 | if ( is_wp_error( $post_ID ) ) |
| | 1969 | return new IXR_Error( 500, $post_ID->get_error_message() ); |
| | 1970 | |
| | 1971 | if ( ! $post_ID ) |
| | 1972 | return new IXR_Error( 401, __( 'Sorry, your entry could not be posted. Something wrong happened.' ) ); |
| | 1973 | |
| | 1974 | return strval( $post_ID ); |
| | 1975 | } |
| | 1976 | |
| | 1977 | /* |
| | 1978 | * Update a post for any registered post type. |
| | 1979 | * |
| | 1980 | * @since 3.4 |
| | 1981 | * @uses wp_newPost() |
| | 1982 | * @uses do_action() Calls 'xmlrpc_call' passing 'wp.editPost' |
| | 1983 | * |
| | 1984 | * @param array $args Method parameters. Contains: |
| | 1985 | * - blog_id |
| | 1986 | * - username |
| | 1987 | * - password |
| | 1988 | * - post_id |
| | 1989 | * - content_struct |
| | 1990 | * @return true on success |
| | 1991 | */ |
| | 1992 | function wp_editPost($args) { |
| | 1993 | $this->escape( $args ); |
| | 1994 | |
| | 1995 | $blog_id = (int) $args[0]; // we will support this in the near future |
| | 1996 | $username = $args[1]; |
| | 1997 | $password = $args[2]; |
| | 1998 | $post_id = $args[3]; |
| | 1999 | $content_struct = $args[4]; |
| | 2000 | |
| | 2001 | if ( ! $user = $this->login($username, $password) ) |
| | 2002 | return $this->error; |
| | 2003 | |
| | 2004 | do_action( 'xmlrpc_call', 'wp.editPost' ); |
| | 2005 | |
| | 2006 | $post = get_post( $post_id, ARRAY_A ); |
| | 2007 | |
| | 2008 | if ( empty( $post["ID"] ) ) |
| | 2009 | return new IXR_Error( 404, __( 'Invalid post ID.' ) ); |
| | 2010 | |
| | 2011 | // convert the date field back to IXR form |
| | 2012 | $post['post_date'] = new IXR_Date( mysql2date( 'Ymd\TH:i:s', $post['post_date'], false ) ); |
| | 2013 | |
| | 2014 | // ignore the existing GMT date if it is empty or a non-GMT date was supplied in $content_struct, |
| | 2015 | // since _wp_insertPost will ignore the non-GMT date if the GMT date is set |
| | 2016 | if ( $post['post_date_gmt'] == '0000-00-00 00:00:00' || isset( $content_struct['post_date'] ) ) |
| | 2017 | unset( $post['post_date_gmt'] ); |
| | 2018 | else |
| | 2019 | $post['post_date_gmt'] = new IXR_Date( mysql2date( 'Ymd\TH:i:s', $post['post_date_gmt'], false ) ); |
| | 2020 | |
| | 2021 | $this->escape( $post ); |
| | 2022 | $merged_content_struct = array_merge( $post, $content_struct ); |
| | 2023 | |
| | 2024 | $retval = $this->_wp_insertPost( $user, $merged_content_struct ); |
| | 2025 | if ( $retval instanceof IXR_Error ) |
| | 2026 | return $retval; |
| | 2027 | |
| | 2028 | return true; |
| | 2029 | } |
| | 2030 | |