Esempio n. 1
0
/**
 * Get WordPress post type in various ways.
 *
 * @param  int $post_id
 *
 * @return string
 */
function papi_get_post_type($post_id = null)
{
    if ($post_type = papi_get_or_post('post_type')) {
        return $post_type;
    }
    $post_id = papi_get_post_id($post_id);
    if ($post_id !== 0) {
        return strtolower(get_post_type($post_id));
    }
    $page = papi_get_qs('page');
    if (is_string($page) && strpos(strtolower($page), 'papi-add-new-page,') !== false) {
        $exploded = explode(',', $page);
        if (empty($exploded[1])) {
            return '';
        }
        return $exploded[1];
    }
    // If only `post-new.php` without any querystrings
    // it would be the post post type.
    $req_uri = $_SERVER['REQUEST_URI'];
    $exploded = explode('/', $req_uri);
    $last = end($exploded);
    if ($last === 'post-new.php') {
        return 'post';
    }
    return '';
}
 /**
  * Render tools page view.
  */
 public function render_view()
 {
     $page_view = (string) papi_get_qs('view');
     if (empty($page_view)) {
         $page_view = 'management-start';
     }
     $this->view->render($page_view);
 }
 /**
  * Prepare taxonomy types, add standard taxonomy if it should be added.
  *
  * @param  array $taxonomy_types
  *
  * @return array
  */
 protected function prepare_taxonomy_types(array $taxonomy_types)
 {
     $taxonomy = papi_get_qs('taxonomy');
     if (papi_filter_settings_show_standard_taxonomy_type($taxonomy)) {
         $id = sprintf('papi-standard-%s-type', $taxonomy);
         $taxonomy_type = new Papi_Taxonomy_Type($id);
         $taxonomy_type->id = $id;
         $taxonomy_type->name = papi_filter_settings_standard_taxonomy_type_name($taxonomy);
         $taxonomy_type->taxonomy = [$taxonomy];
         $taxonomy_types[] = $taxonomy_type;
     }
     usort($taxonomy_types, function ($a, $b) {
         return strcmp($a->name, $b->name);
     });
     return papi_sort_order(array_reverse($taxonomy_types));
 }
Esempio n. 4
0
 /**
  * Load property from page type.
  *
  * @param  string $slug
  * @param  string $child_slug
  *
  * @return object
  */
 public function get_property($slug, $child_slug = '')
 {
     $page_type_id = str_replace('papi/', '', papi_get_qs('page'));
     if (empty($page_type_id)) {
         $page_types = papi_get_all_page_types(false, null, true);
         $property = null;
         foreach ($page_types as $index => $page_type) {
             if ($property = $page_type->get_property($slug, $child_slug)) {
                 break;
             }
         }
         if (is_null($property)) {
             return;
         }
         return $property;
     }
     $page_type = papi_get_page_type_by_id($page_type_id);
     if ($page_type instanceof Papi_Option_Type === false) {
         return;
     }
     return $page_type->get_property($slug, $child_slug);
 }
Esempio n. 5
0
 /**
  * Render the property.
  */
 public function render()
 {
     // Check so the property has a type and capabilities on the property.
     if (!papi_current_user_is_allowed($this->get_option('capabilities'))) {
         return;
     }
     // A disabled property should not be rendered.
     if ($this->disabled()) {
         return;
     }
     // Only render if it's the right language if the definition exist.
     if ($this->get_option('lang') === strtolower(papi_get_qs('lang'))) {
         $render = true;
     } else {
         $render = $this->get_option('lang') === false && papi_is_empty(papi_get_qs('lang'));
     }
     if ($this->display()) {
         $this->display = $this->render_is_allowed_by_rules();
     }
     $this->render_row_html();
     $this->render_hidden_html();
     $this->render_rules_json();
 }
Esempio n. 6
0
 /**
  * Render the property.
  */
 public function render()
 {
     // Check if current user can view the property.
     if (!$this->current_user_can()) {
         return;
     }
     // A disabled property should not be rendered.
     if ($this->disabled()) {
         return;
     }
     // Only render if it's the right language if the definition exist.
     if ($this->get_option('lang') === strtolower(papi_get_qs('lang'))) {
         $this->display = true;
     } else {
         $this->display = $this->get_option('lang') === false && papi_is_empty(papi_get_qs('lang'));
     }
     // Check rules.
     if ($this->display()) {
         $this->display = $this->render_is_allowed_by_rules();
     }
     $this->render_row_html();
     $this->render_hidden_html();
     $this->render_rules_json();
 }
Esempio n. 7
0
 /**
  * Load property from page type.
  *
  * @param  string $slug
  * @param  string $child_slug
  *
  * @return object
  */
 public function get_property($slug, $child_slug = '')
 {
     $content_type_id = papi_get_qs('page');
     if (empty($content_type_id)) {
         $property = null;
         $content_types = papi_get_all_content_types(['types' => 'option']);
         foreach ($content_types as $index => $content_type) {
             if ($property = $content_type->get_property($slug, $child_slug)) {
                 $this->option_type = $content_type;
                 break;
             }
         }
         if (is_null($property)) {
             return;
         }
         return $property;
     }
     $content_type = papi_get_content_type_by_id($content_type_id);
     if (!papi_is_option_type($content_type)) {
         return;
     }
     $this->option_type = $content_type;
     return $content_type->get_property($slug, $child_slug);
 }
Esempio n. 8
0
 /**
  * Load property from page type.
  *
  * @param  string $slug
  * @param  string $child_slug
  *
  * @return null|object
  */
 public function get_property($slug, $child_slug = '')
 {
     $entry_type_id = papi_get_qs('page');
     if (empty($entry_type_id)) {
         $property = null;
         $entry_types = papi_get_all_entry_types(['types' => 'option']);
         foreach ($entry_types as $entry_type) {
             if ($property = $entry_type->get_property($slug, $child_slug)) {
                 break;
             }
         }
         if (is_null($property)) {
             return;
         }
         return $property;
     }
     $entry_type = papi_get_entry_type_by_id($entry_type_id);
     if ($entry_type instanceof Papi_Option_Type === false) {
         return;
     }
     if ($property = $entry_type->get_property($slug, $child_slug)) {
         return $this->prepare_property($property);
     }
 }
Esempio n. 9
0
 /**
  * Menu callback that loads right view depending on what the `page` query string says.
  */
 public function render_view()
 {
     if (strpos(papi_get_qs('page'), 'papi') !== false) {
         $page = str_replace('papi-', '', papi_get_qs('page'));
         $res = preg_replace('/\\,.*/', '', $page);
         if (is_string($res)) {
             $page_view = $res;
         }
     }
     if (!isset($page_view)) {
         $page_view = null;
     }
     if (!is_null($page_view)) {
         $view = new Papi_Admin_View();
         $view->render($page_view);
     } else {
         echo '<h2>Papi - 404</h2>';
     }
 }
Esempio n. 10
0
 /**
  * Get property html via GET.
  *
  * GET /papi-ajax/?action=get_property
  */
 public function get_property()
 {
     $default_options = Papi_Core_Property::create()->get_options();
     $keys = array_keys(get_object_vars($default_options));
     $options = papi_get_qs($keys, true);
     if ($property = papi_property($options)) {
         ob_start();
         $property->render_ajax_request();
         $html = ob_get_clean();
         wp_send_json(['html' => utf8_encode($html)]);
     } else {
         $this->render_error('No property found');
     }
 }
 /**
  * Render AJAX request.
  */
 public function render_ajax_request()
 {
     $items = $this->get_settings_properties();
     if (papi_doing_ajax()) {
         $counter = papi_get_qs('counter');
         $this->counter = intval($counter);
     }
     $this->render_properties($items, false);
 }
Esempio n. 12
0
/**
 * Get content type id.
 *
 * @return string
 */
function papi_get_content_type_id()
{
    $content_type_id = papi_get_qs('content_type');
    /**
     * Change content type id.
     *
     * @param string $content_type_id
     */
    return apply_filters('papi/content_type_id', $content_type_id);
}
Esempio n. 13
0
 /**
  * Get terms via GET.
  *
  * GET /papi-ajax/?action=get_terms
  */
 public function get_terms()
 {
     $query = papi_get_qs('query') ?: [];
     $query = is_array($query) ? $query : [];
     $taxonomy = papi_get_qs('taxonomy') ?: '';
     $args = array_merge($query, ['fields' => 'id=>name']);
     $terms = [];
     if (taxonomy_exists($taxonomy)) {
         $terms = get_terms($taxonomy, $args);
     }
     wp_send_json($terms);
 }
Esempio n. 14
0
 /**
  * Get Entry Type instance.
  *
  * @return Papi_Entry_Type|false
  */
 private function get_entry_type()
 {
     if ($this->entry_type instanceof Papi_Entry_Type) {
         return $this->entry_type;
     }
     $entry_type_id = papi_get_entry_type_id();
     // If the entry type id is empty try to load
     // the entry type id from `page` query string.
     //
     // Example:
     //   /wp-admin/options-general.php?page=papi/option/site-option-type
     if (empty($entry_type_id)) {
         $entry_type_id = preg_replace('/^papi\\/\\w+\\//', '', papi_get_qs('page'));
     }
     // Use the default entry type id if empty.
     if (empty($entry_type_id)) {
         $entry_type_id = papi_get_entry_type_id();
     }
     // If no entry type id exists Papi can't setup a entry type.
     if (empty($entry_type_id)) {
         return false;
     }
     return $this->entry_type = papi_get_entry_type_by_id($entry_type_id);
 }
Esempio n. 15
0
/**
 * Load the content type id on a post types.
 *
 * @param  string $content_type_id
 *
 * @return string
 */
function papi_load_page_type_id($content_type_id = '')
{
    $key = papi_get_page_type_key();
    $post_id = papi_get_post_id();
    $post_type = papi_get_post_type($post_id);
    // If we have a post id we can load the content type id
    // from the post.
    if ($post_id > 0) {
        $meta_value = get_post_meta($post_id, $key, true);
        $content_type_id = empty($meta_value) ? '' : $meta_value;
    }
    // Try to fetch the content type id from `page_type`
    // query string.
    if (empty($content_type_id)) {
        $content_type_id = papi_get_qs('page_type');
    }
    // When using `only_page_type` filter we need to fetch the value since it
    // maybe not always saved in the database.
    if (empty($content_type_id)) {
        $content_type_id = papi_filter_settings_only_page_type($post_type);
    }
    // Load right content type from the parent post id.
    if (empty($content_type_id)) {
        $meta_value = get_post_meta(papi_get_parent_post_id(), $key, true);
        $content_type_id = empty($meta_value) ? '' : $meta_value;
    }
    // Load content type id from the container if it exists.
    if (empty($content_type_id)) {
        $key = sprintf('content_type_id.%s', $post_type);
        if (papi()->exists($key)) {
            return papi()->make($key);
        }
    }
    return $content_type_id;
}
Esempio n. 16
0
/**
 * Get entry type id.
 *
 * @param  int $id
 * @param  string $type
 *
 * @return string
 */
function papi_get_entry_type_id($id = 0, $type = null)
{
    $type = papi_get_meta_type($type);
    $id = papi_get_meta_id($type, $id);
    if ($id > 0) {
        if ($meta_value = get_metadata($type, $id, papi_get_page_type_key(), true)) {
            return $meta_value;
        }
    }
    $entry_type_id = papi_get_qs('entry_type');
    /**
     * Change entry type id.
     *
     * @param  string $entry_type_id
     * @param  string $type
     *
     * @return string
     */
    return apply_filters('papi/entry_type_id', $entry_type_id, $type);
}
Esempio n. 17
0
/**
 * Get right meta type value. It will treat option
 * as a meta type even if isn't a real meta type.
 *
 * @param  string $type
 *
 * @return string|null
 */
function papi_get_meta_type($type = null)
{
    if ($meta_type = papi_get_qs('meta_type')) {
        return $meta_type;
    }
    switch ($type) {
        case 'option':
            return 'option';
        case 'post':
        case 'page':
            return 'post';
        case 'taxonomy':
        case 'term':
            return 'term';
        default:
            break;
    }
    $request_uri = $_SERVER['REQUEST_URI'];
    $parsed_url = parse_url($request_uri);
    if (!empty($parsed_url['query'])) {
        // Taxonomy page in admin.
        if (is_admin() && preg_match('/taxonomy=/', $parsed_url['query'])) {
            return 'term';
        }
        // Option page in admin.
        if (is_admin() && preg_match('/page\\=papi(\\%2F|\\/)option/', $parsed_url['query'])) {
            return 'option';
        }
    }
    // When doing ajax we need to check if it's a taxonomy ajax or a post type ajax.
    if (is_admin() && defined('DOING_AJAX') && DOING_AJAX) {
        if (isset($_POST['taxonomy'])) {
            return 'term';
        }
        if (isset($_POST['post_type'])) {
            return 'post';
        }
    }
    // On the frontend term should be returned if on a category or tag page.
    if (!is_admin() && (is_category() || is_tag())) {
        return 'term';
    }
    // Check queried object for right meta type.
    if ($obj = get_queried_object()) {
        if ($obj instanceof WP_Term || isset($obj->term_id)) {
            return 'term';
        }
        if ($obj instanceof WP_Post || isset($obj->post_id)) {
            return 'post';
        }
    }
    // Default was has to be set here since we trying to figure out
    // which url conform which meta type.
    if (is_null($type)) {
        $type = 'post';
    }
    // If meta type exists as a filter we can return it.
    if (function_exists("get_{$type}_meta")) {
        return $type;
    }
}
Esempio n. 18
0
/**
 * Get query string if it exists and is not empty.
 *
 * @param  array|string $qs
 * @param  bool         $keep_keys
 *
 * @return array|string
 */
function papi_get_qs($qs, $keep_keys = false)
{
    if (!is_string($qs) && !is_array($qs)) {
        return;
    }
    if (is_array($qs)) {
        if ($keep_keys) {
            $results = [];
            foreach ($qs as $key) {
                $value = papi_get_qs($key);
                if (!papi_is_empty($value)) {
                    $results[$key] = $value;
                }
            }
            return $results;
        } else {
            return array_map('papi_get_qs', $qs);
        }
    }
    if (isset($_GET[$qs]) && !empty($_GET[$qs])) {
        $value = $_GET[$qs];
        if (is_string($value)) {
            $value = sanitize_text_field($value);
        }
        if ($value === 'false') {
            $value = false;
        }
        if ($value === 'true') {
            $value = true;
        }
        return $value;
    }
}
Esempio n. 19
0
/**
 * Get page type id.
 *
 * @param  int $post_id
 *
 * @return string
 */
function papi_get_page_type_id($post_id = 0)
{
    $post_id = papi_get_post_id($post_id);
    $key = papi_get_page_type_key();
    $page_type = '';
    if ($post_id !== 0) {
        $meta_value = get_post_meta($post_id, $key, true);
        $page_type = empty($meta_value) ? '' : $meta_value;
    }
    if (empty($page_type)) {
        $page_type = str_replace('papi/', '', papi_get_qs('page_type'));
    }
    if (empty($page_type)) {
        $page_type = papi_get_sanitized_post(papi_get_page_type_key());
    }
    // Load right page type from a post query string
    if (empty($page_type)) {
        $meta_value = get_post_meta(papi_get_parent_post_id(), $key, true);
        $page_type = empty($meta_value) ? '' : $meta_value;
    }
    // Load page type id from the container if it exists or
    // load it from `papi_get_all_page_types`.
    if (empty($page_type)) {
        $post_type = papi_get_post_type();
        $load_once = papi_filter_core_load_one_type_on();
        $collection_key = 'core.page_type.' . $post_type;
        if (in_array($post_type, $load_once)) {
            if (papi()->exists($collection_key)) {
                return papi()->make($collection_key);
            }
            if ($page_types = papi_get_all_page_types(false, $post_type)) {
                return $page_types[0]->get_id();
            }
        }
    }
    return $page_type;
}
Esempio n. 20
0
    /**
     * Filter page types in post type list.
     */
    public function restrict_page_types()
    {
        $post_types = papi_get_post_types();
        if (in_array($this->post_type, $post_types, true)) {
            $page_types = papi_get_all_page_types($this->post_type);
            $page_types = array_map(function ($page_type) {
                return ['name' => $page_type->name, 'value' => $page_type->get_id()];
            }, $page_types);
            // Add the standard page that isn't a real page type.
            if (papi_filter_settings_show_standard_page_type_in_filter($this->post_type)) {
                $page_types[] = ['name' => papi_filter_settings_standard_page_type_name($this->post_type), 'value' => 'papi-standard-page'];
            }
            usort($page_types, function ($a, $b) {
                return strcmp(strtolower($a['name']), strtolower($b['name']));
            });
            ?>
			<select name="page_type" class="postform">
				<option value="0" selected><?php 
            esc_html_e('All types', 'papi');
            ?>
</option>
				<?php 
            foreach ($page_types as $page_type) {
                printf('<option value="%s" %s>%s</option>', esc_attr($page_type['value']), papi_get_qs('page_type') === $page_type['value'] ? ' selected' : '', esc_html($page_type['name']));
            }
            ?>
			</select>
			<?php 
        }
    }
Esempio n. 21
0
 /**
  * Load right Papi file if it exists.
  *
  * @return bool
  */
 public function setup_papi()
 {
     // If the post type isn't in the post types array we can't proceed.
     if (in_array($this->post_type, ['revision', 'nav_menu_item'])) {
         return false;
     }
     if (empty($this->page_type_id)) {
         // If only page type is used, override the page type value.
         $this->page_type_id = papi_filter_settings_only_page_type($this->post_type);
         if (empty($this->page_type_id)) {
             // Load page types that don't have any real post type.
             $this->page_type_id = str_replace('papi/', '', papi_get_qs('page'));
         }
         if (empty($this->page_type_id)) {
             $this->page_type_id = papi_get_page_type_id();
         }
     }
     if (empty($this->page_type_id)) {
         return false;
     }
     $this->page_type = papi_get_page_type_by_id($this->page_type_id);
     // Do a last check so we can be sure that we have a page type instance.
     return $this->page_type instanceof Papi_Page_Type;
 }
 /**
  * Render AJAX request.
  */
 public function render_ajax_request()
 {
     $items = null;
     $layouts = $this->get_settings_layouts();
     if (defined('DOING_PAPI_AJAX') && DOING_PAPI_AJAX) {
         $counter = papi_get_qs('counter');
         $this->counter = intval($counter);
         $flexible_layout = papi_get_qs('flexible_layout');
         foreach ($layouts as $layout) {
             if ($layout['slug'] === $flexible_layout) {
                 $items = $layout;
                 break;
             }
         }
     }
     if (!empty($items)) {
         $this->render_properties($items, false);
     }
 }
Esempio n. 23
0
 /**
  * Load right Papi file if it exists.
  *
  * @return bool
  */
 public function setup_papi()
 {
     // If the post type isn't in the post types array we can't proceed.
     if (in_array($this->post_type, ['revision', 'nav_menu_item'])) {
         return false;
     }
     $content_type_id = papi_get_content_type_id();
     // If a post type exists, try to load the content type id
     // from only page type filter.
     if ($this->post_type) {
         $content_type_id = papi_filter_settings_only_page_type($this->post_type);
     }
     // If the content type id is empty try to load
     // the content type id from `page` query string.
     //
     // Example:
     //   /wp-admin/options-general.php?page=papi/option/site-option-type
     if (empty($content_type_id)) {
         $content_type_id = preg_replace('/^papi\\/\\w+\\//', '', papi_get_qs('page'));
     }
     // Use the default content type id if empty.
     if (empty($content_type_id)) {
         $content_type_id = papi_get_content_type_id();
     }
     // If no content type id exists Papi can't setup a content type.
     if (empty($content_type_id)) {
         return false;
     }
     // Do a last check so we can be sure that we have a page type instance.
     return ($this->page_type = papi_get_content_type_by_id($content_type_id)) instanceof Papi_Content_Type;
 }
Esempio n. 24
0
		</table>
		<?php 
    }
}
?>
<div class="wrap">
	<div class="papi-options-logo"></div>
	<h1><?php 
echo papi()->name;
?>
</h1>

	<br/>

	<?php 
$page_type = papi_get_qs('page_type');
$page_type = papi_get_page_type_by_id($page_type);
if (empty($page_type)) {
    ?>
		<h3><?php 
    _e('Cannot find the page type', 'papi');
    ?>
</h3>
		<p>
			<a href="tools.php?page=papi"><?php 
    echo esc_html('Back to list', 'papi');
    ?>
</a>
		</p>
	<?php 
} else {
Esempio n. 25
0
/**
 * Load the entry type id on a post types.
 *
 * @param  string $entry_type_id
 *
 * @return string
 */
function papi_load_page_type_id($entry_type_id = '')
{
    $key = papi_get_page_type_key();
    $post_id = papi_get_post_id();
    $post_type = papi_get_post_type($post_id);
    // Try to load the entry type id from only page type filter.
    if (empty($entry_type_id)) {
        $entry_type_id = papi_filter_settings_only_page_type($post_type);
    }
    // If we have a post id we can load the entry type id from the post.
    if (empty($entry_type_id) && $post_id > 0) {
        $meta_value = get_post_meta($post_id, $key, true);
        $entry_type_id = empty($meta_value) ? '' : $meta_value;
    }
    // Try to fetch the entry type id from `page_type` query string.
    if (empty($entry_type_id)) {
        $entry_type_id = papi_get_qs('page_type');
    }
    // Load right entry type from the parent post id.
    if (empty($entry_type_id)) {
        $meta_value = get_post_meta(papi_get_parent_post_id(), $key, true);
        $entry_type_id = empty($meta_value) ? '' : $meta_value;
    }
    // Try to load the entry type from all page types and check
    // if only one exists of that post type.
    //
    // The same as only page type filter but without the filter.
    if (empty($entry_type_id)) {
        $key = sprintf('entry_type_id.post_type.%s', $post_type);
        if (papi()->exists($key)) {
            return papi()->make($key);
        }
        $entries = papi_get_all_page_types($post_type);
        if (count($entries) === 1) {
            $entry_type_id = $entries[0]->get_id();
            papi()->bind($key, $entry_type_id);
        }
    }
    return $entry_type_id;
}