Publish via page tree does not check for any requirements

[flipzoom]

Short description of the issue

I have a template and this has, for example, a required field. In this example, an image field. If I do not fill this field and try to publish the page in edit mode, this does not work and I get an error message. Up to here everything is all right. Now I try to publish the page over the page tree and it works. No requirements are checked here. This has led to some annoying errors on a customer's website.

Expected behavior

When publishing via the page tree, requirements must also be checked and an error message must be output if something is missing.

Actual behavior

Pages are published without verification.

Optional: Screenshots/Links that demonstrate the issue

Setup/Environment

• ProcessWire version: 3.0.61

[Toutouwai]

Setting a field to 'required' has never been a foolproof way to ensure a field value will always be populated - you need to check that the field has a value in your template to avoid errors.

See the blog post here: https://processwire.com/blog/posts/processwire-3.0.14-updates-file-compiler-fields-and-more/#required-fields-in-processwire

[ryancramerdesign]

The "required" setting is an input requirement, not specifically a publish requirement. It's also part of Inputfield settings, which aren't known or applicable outside of the page editor. Though I understand what you are saying that you have the need to support it there in the page tree. The best route might be to setup a hook in /site/templates/admin.php for your specific case. The following will cause an alert box to pop-up to the user when they click the "Pub" action, and your indicated requirements aren't met:

$pages->addHookAfter('publishReady', function($event) {
  $page = $event->arguments(0);
  $fieldName = 'some_field_name';
  $value = $page->get($fieldName);
  if(empty($value)) {
    throw new WireException("Please populate $fieldName before publish");
  }
}); 

[LostKobrakai]

Isn't it possible to use $page->publishable() here?

[ryancramerdesign]

Using Page::publishable() probably isn't ideal here because if that method returns false, then the user isn't going to be able to edit an already published page. Though I suppose you could add some more checks in your hook, to ensure it only can return false or pages that are currently unpublished and missing some value. But because this method is called so often, it's one that you don't want to perform any expensive checks in. Whereas a publishReady hook might be okay even if it had to do more expensive checks.

[teppokoivula]

Just pointing out that, in my opinion, current behaviour is very weird. Once again I get what you mean by the difference of input requirement vs. publish requirement, but regular users probably won't.

If you're able to publish a page in one view, but not another where things (again from regular users point of view) should be identical, that's definitely inconsistent and pretty bad for user experience :)

[Toutouwai]

@FlipZoomMedia, another approach would be to disallow non-superusers (or users with a given role) to publish pages from the page tree. You could use a hook to remove the 'Pub' option from the extra actions so editors must open Page Edit before publishing a page, where the required inputfields will be checked.

IMO this is preferable in any case - I'd like editors to actually look at what they are publishing before they do so.

$wire->addHookAfter('ProcessPageListActions::getExtraActions', function($event) {
    $extras = $event->return;
    if(!$this->user->isSuperuser()) unset($extras['pub']);
    $event->return = $extras;
});

[Toutouwai]

BTW, to expand @ryancramerdesign's publishReady hook to all required fields on a page:

$pages->addHookAfter('publishReady', function($event) {
    $page = $event->arguments(0);
    $required = $page->getInputfields()->find("required=1");
    $unpopulated = array();
    foreach($required as $inputfield) {
        $field_name = $inputfield->name;
        $value = $page->get($field_name);
        if(!$value || $value instanceof \Traversable && !count($value)) $unpopulated[] = $field_name;
    }
    if(count($unpopulated)) {
        throw new WireException('Please populate ' . implode(', ', $unpopulated) . ' before publishing');
    }
});

But this still doesn't account for inputfields that have their required state set via inputfield dependencies. To support these you would have to port the validation functions in inputfields.js to PHP. I made a start on this but it was going to be quite a job and I think I'd rather just remove the ability to publish from the tree as per the previous comment.

[netcarver]

@ryancramerdesign @Toutouwai @FlipZoomMedia @teppokoivula @LostKobrakai How do you feel this issue should be progressed?

[ryancramerdesign]

@netcarver I don't think there's a straightforward way to support it without one actually going to the page editor. Like Toutouwai mentioned there's potential for input-level rules that are only known and applicable during form input and/or processing. My opinion is maybe we remove the "Pub" button from non-superusers. Though I think for most the current behavior likely isn't consequential. So another possibility is to leave as-is and help people along with these hooks for cases where it matters, or maybe make it possible to disable the Pub button.

[flipzoom]

or maybe make it possible to disable the Pub button.

@ryancramerdesign I think this is the most flexible and cleanest solution. A configurable option in the module "ProcessPageList", whether publishing via the page tree should be possible or not. Maybe even separated by roles.

[szabeszg]

or maybe make it possible to disable the Pub button.

Could it be a template level setting? That way we could only disable it for the pages where it matters. Adding role based control to the mix would be welcome too, if that is possible, of course.

[netcarver]

@ryancramerdesign Sounds like there is support for this idea.

[ryancramerdesign]

I've applied a solution for this. Here's how it works. If a page is saved (in the admin) and errors are generated by the page editor form, the page receives a Page::statusIncomplete status, indicating something may be missing on the page. When the page is saved without error, this status is removed.

Over to the page list, there is no "Pub" button if the page has the "incomplete" status. In addition, it shows a warning icon next to any pages that have the status. This indicates the page reported an error the last time it was saved, so it might potentially have incomplete data.

There's a catch though. This only applies to pages saved from this point forward, and only in the page editor. That's because the nature of the system is that input requirements are determined and checked during processing of a submitted Inputfield form. So if you've got an existing unpublished page in your system that is missing some required fields (or has some other error), then ProcessWire isn't going to know that it's incomplete until it processes the submitted page editor form.

Using the Page::statusIncomplete means we prevent publishing for any input error on the page, not just missing required fields. I think this is important because different Fieldtypes and Inputfields have different configurable requirements, and it's not something that PW knows about until the form to edit them is submitted and processed. So now when a page edit form is submitted and there are errors, the page gets flagged as incomplete. As result, PW now has a way of remembering that an error occurred when saving a page, whereas previously it did not.

At present this solution adds no overhead whatsoever. We could add more overhead and go further with this, though for the goal of not showing a Pub button when a page is incomplete, this accomplishes it for pages that are saved in the page editor from this point forward.