initial commit of starter install drupal 7
This commit is contained in:
Bachir Soussi Chiadmi
+339
@@ -0,0 +1,339 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Lesser General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License.
|
||||
@@ -0,0 +1,38 @@
|
||||
PUBLISH CONTENT MODULE
|
||||
|
||||
The Publish Content module allows users to publish and unpublish nodes,
|
||||
on a per "node type" basis or for all "node types", without granting users
|
||||
the very broad "administer nodes" permission.
|
||||
|
||||
It allows easily to create editor or moderator roles by granting them
|
||||
either publishing or unpublishing permissions, or both.
|
||||
|
||||
This module is also integrated with the Views module:
|
||||
you can add a publish/unpublish link on all your views, making it easy
|
||||
to create lists for reviewers, editors and publishers.
|
||||
|
||||
|
||||
INSTALLATION
|
||||
|
||||
Put the module in your drupal modules directory and enable it in admin/modules.
|
||||
|
||||
Then, you just need to go to the Drupal permissions page,
|
||||
and set the various permissions:
|
||||
- "publish all content": you can publish any node
|
||||
- "publish 'nodetype' content": you can publish any node whose type is 'nodetype'
|
||||
- "unpublish all content": you can unpublish any node
|
||||
- "publish 'nodetype' content": you can publish any node whose type is 'nodetype'
|
||||
- "un/publish editable content": publish or unpublish nodes where the user has
|
||||
full edit permissions of the node concerned (note: check text formats access)
|
||||
|
||||
|
||||
USAGE
|
||||
|
||||
A tab button (like Edit and View) 'Publish' or 'Unpublish' should appear on the
|
||||
node edit and view pages.
|
||||
Click on 'Publish' to publish and 'Unpublish' to unpublish, it's that simple!
|
||||
|
||||
CONFIGURATION
|
||||
|
||||
admin/config/content/publishcontent
|
||||
Here you can disable the display of Publish/Unpublish tabs.
|
||||
@@ -0,0 +1,27 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Contains page callbacks for publishcontent
|
||||
*/
|
||||
|
||||
/**
|
||||
* Administration settings form.
|
||||
*/
|
||||
function publishcontent_config_form($form, &$form_state) {
|
||||
|
||||
$form['publishcontent_method'] = array(
|
||||
'#type' => 'radios',
|
||||
'#title' => t('Quick publish method'),
|
||||
'#default_value' => variable_get('publishcontent_method', PUBLISHCONTENT_METHOD_TABS),
|
||||
'#description' => t('Choose the quick links method. With no quick links, the published checkbox will still appear on the node edit form. Note that a Drupal cache clear is required after changing this.'),
|
||||
'#options' => array(
|
||||
PUBLISHCONTENT_METHOD_NONE => t('None.'),
|
||||
PUBLISHCONTENT_METHOD_ACTION_LINKS => t('Action links on node view.'),
|
||||
PUBLISHCONTENT_METHOD_BUTTON => t('Button.'),
|
||||
PUBLISHCONTENT_METHOD_TABS => t('Tabs.'),
|
||||
),
|
||||
);
|
||||
|
||||
return system_settings_form($form);
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Describe hooks provided by the publishcontent module.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Allow other modules the ability to modify access to the publish controls.
|
||||
*
|
||||
* Modules may implement this hook if they want to have a say in whether or not
|
||||
* a given user has access to perform publish action on a node.
|
||||
*
|
||||
* @param node $node
|
||||
* A node object being checked
|
||||
* @param user $account
|
||||
* The user wanting to publish the node.
|
||||
*
|
||||
* @return bool|NULL
|
||||
* PUBLISHCONTENT_ACCESS_ALLOW - if the account can publish the node
|
||||
* PUBLISHCONTENT_ACCESS_DENY - if the user definetley can not publish
|
||||
* PUBLISHCONTENT_ACCESS_IGNORE - This module wan't change the outcome.
|
||||
* It is typically better to return IGNORE than DENY. If no module returns
|
||||
* ALLOW then the account will be denied publish access. If one module
|
||||
* returns DENY then the user will denied even if another module returns
|
||||
* ALLOW.
|
||||
*/
|
||||
function hook_publishcontent_publish_access($node, $account) {
|
||||
$access = !$node->status &&
|
||||
(user_access('administer nodes')
|
||||
|| user_access('publish any content')
|
||||
|| (user_access('publish own content') && $account->uid == $node->uid)
|
||||
|| (user_access('publish editable content') && node_access('update', $node))
|
||||
|| (user_access('publish own ' . check_plain($node->type) . ' content', $account) && $account->uid == $node->uid)
|
||||
|| user_access('publish any ' . check_plain($node->type) . ' content')
|
||||
|| (user_access('publish editable ' . check_plain($node->type) . ' content') && node_access('update', $node))
|
||||
);
|
||||
|
||||
if ($access) {
|
||||
// The user can publish the node according to this hook.
|
||||
// If another hook denys access they will be denied.
|
||||
return PUBLISHCONTENT_ACCESS_ALLOW;
|
||||
}
|
||||
|
||||
// This function does not believe they can publish but is
|
||||
// not explicitly denying access to publish. If no other hooks
|
||||
// allow it then the user will be denied.
|
||||
return PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allow other modules the ability to modify access to the unpublish controls.
|
||||
*
|
||||
* Modules may implement this hook if they want to have a say in whether or not
|
||||
* a given user has access to perform unpublish action on a node.
|
||||
*
|
||||
* @param node $node
|
||||
* A node object being checked
|
||||
* @param user $account
|
||||
* The user wanting to unpublish the node.
|
||||
*
|
||||
* @return bool|NULL
|
||||
* PUBLISHCONTENT_ACCESS_ALLOW - if the user can unpublish the node.
|
||||
* PUBLISHCONTENT_ACCESS_DENY - if the user definetley cannot unpublish.
|
||||
* PUBLISHCONTENT_ACCESS_IGNORE - This module wan't change the outcome.
|
||||
* It is typically better to return IGNORE than DENY. If no module returns
|
||||
* ALLOW then the user will be denied access. If one module returns
|
||||
* DENY then the user will denied even if another module returns
|
||||
* ALLOW.
|
||||
*/
|
||||
function hook_publishcontent_unpublish_access($node, $account) {
|
||||
$access = $node->status &&
|
||||
(user_access('administer nodes')
|
||||
|| user_access('unpublish any content')
|
||||
|| (user_access('unpublish own content') && $user->uid == $node->uid)
|
||||
|| (user_access('unpublish editable content') && node_access('update', $node))
|
||||
|| (user_access('unpublish own ' . check_plain($node->type) . ' content', $user) && $user->uid == $node->uid)
|
||||
|| user_access('unpublish any ' . check_plain($node->type) . ' content')
|
||||
|| (user_access('unpublish editable ' . check_plain($node->type) . ' content') && node_access('update', $node))
|
||||
);
|
||||
|
||||
if ($access) {
|
||||
// The user is allowed to unpublish the node according to this hook.
|
||||
// If another hook denys access they will be denied.
|
||||
return PUBLISHCONTENT_ACCESS_ALLOW;
|
||||
}
|
||||
|
||||
// This function does not believe they can publish but is
|
||||
// not explicitly denying access to publish. If no other hooks
|
||||
// allow it then the user will be denied.
|
||||
return PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
name = Publish Content
|
||||
description = "Adds a 'Publish' or 'Unpublish' link on the node edit/view pages, and a 'Publish Link' field if the Views module is enabled."
|
||||
core = 7.x
|
||||
configure = admin/config/content/publishcontent
|
||||
|
||||
files[] = publishcontent_views_handler_field_node_link.inc
|
||||
files[] = tests/publishcontent.test
|
||||
|
||||
; Information added by Drupal.org packaging script on 2014-02-25
|
||||
version = "7.x-1.3"
|
||||
core = "7.x"
|
||||
project = "publishcontent"
|
||||
datestamp = "1393372405"
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Install file for the publish content module.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Copy tabs preference into new variable called publishcontent_method.
|
||||
*/
|
||||
function publishcontent_update_7001() {
|
||||
$new_method = variable_get('publishcontent_tabs', TRUE) ? PUBLISHCONTENT_METHOD_TABS : PUBLISHCONTENT_METHOD_NONE;
|
||||
variable_set('publishcontent_method', $new_method);
|
||||
variable_del('publishcontent_tabs');
|
||||
}
|
||||
@@ -0,0 +1,574 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Add link to publish or unpublish a node, with access control based on the
|
||||
* node type
|
||||
*/
|
||||
|
||||
define('PUBLISHCONTENT_METHOD_NONE', 0);
|
||||
define('PUBLISHCONTENT_METHOD_ACTION_LINKS', 1);
|
||||
define('PUBLISHCONTENT_METHOD_BUTTON', 2);
|
||||
define('PUBLISHCONTENT_METHOD_TABS', 3);
|
||||
|
||||
define('PUBLISHCONTENT_ACCESS_ALLOW', TRUE);
|
||||
define('PUBLISHCONTENT_ACCESS_DENY', FALSE);
|
||||
define('PUBLISHCONTENT_ACCESS_IGNORE', NULL);
|
||||
|
||||
/**
|
||||
* Implements hook_menu().
|
||||
*/
|
||||
function publishcontent_menu() {
|
||||
$items = array();
|
||||
|
||||
$menu_type = _publishcontent_get_menutype();
|
||||
|
||||
$items['admin/config/content/publishcontent'] = array(
|
||||
'title' => 'Publish content settings',
|
||||
'page callback' => 'drupal_get_form',
|
||||
'page arguments' => array('publishcontent_config_form'),
|
||||
'access callback' => 'user_access',
|
||||
'access arguments' => array('administer site configuration'),
|
||||
'description' => 'Configure settings.',
|
||||
'file' => 'publishcontent.admin.inc',
|
||||
'type' => MENU_NORMAL_ITEM,
|
||||
);
|
||||
|
||||
$items['node/%publishcontent_tab/publish/%publishcontent_security_token'] = array(
|
||||
'title' => 'Publish',
|
||||
'page callback' => 'publishcontent_toggle_status',
|
||||
'page arguments' => array(1),
|
||||
'access callback' => '_publishcontent_publish_access',
|
||||
'access arguments' => array(1, 3),
|
||||
'weight' => 5,
|
||||
'type' => $menu_type,
|
||||
'options' => array('attributes' => array('class' => array('publishcontent-link', 'publishcontent-publish'))),
|
||||
'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE,
|
||||
);
|
||||
|
||||
$items['node/%publishcontent_tab/unpublish/%publishcontent_security_token'] = array(
|
||||
'title' => 'Unpublish',
|
||||
'page callback' => 'publishcontent_toggle_status',
|
||||
'page arguments' => array(1),
|
||||
'access callback' => '_publishcontent_unpublish_access',
|
||||
'access arguments' => array(1, 3),
|
||||
'weight' => 5,
|
||||
'type' => $menu_type,
|
||||
'options' => array('attributes' => array('class' => array('publishcontent-link', 'publishcontent-unpublish'))),
|
||||
'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE,
|
||||
);
|
||||
|
||||
return $items;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decide to show the (un)publish tab or not.
|
||||
*/
|
||||
function publishcontent_tab_load($nid) {
|
||||
if (is_numeric($nid)) {
|
||||
$node = node_load($nid);
|
||||
if (variable_get('publishcontent_' . $node->type, FALSE)) {
|
||||
return $node;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to append a security token to prevent XSS.
|
||||
*/
|
||||
function publishcontent_security_token_to_arg($arg, $map, $index) {
|
||||
return drupal_get_token();
|
||||
}
|
||||
|
||||
/**
|
||||
* Access callback for publish action.
|
||||
*/
|
||||
function _publishcontent_publish_access($node, $token = FALSE) {
|
||||
if (!is_object($node)) {
|
||||
return FALSE;
|
||||
}
|
||||
if ($token && !drupal_valid_token($token)) {
|
||||
return FALSE;
|
||||
}
|
||||
if (!variable_get('publishcontent_' . $node->type, FALSE)) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return !$node->status && publishcontent_publish_access($node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Access callback for unpublish action.
|
||||
*/
|
||||
function _publishcontent_unpublish_access($node, $token = FALSE) {
|
||||
if (!is_object($node)) {
|
||||
return FALSE;
|
||||
}
|
||||
if ($token && !drupal_valid_token($token)) {
|
||||
return FALSE;
|
||||
}
|
||||
if (!variable_get('publishcontent_' . $node->type, FALSE)) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return $node->status && publishcontent_unpublish_access($node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if a user has publish permission to a given node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node object to check.
|
||||
* @param user $account
|
||||
* The user account to check - defaults to the logged in user.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if user can publish the node.
|
||||
*/
|
||||
function publishcontent_publish_access($node, $account = NULL) {
|
||||
$access = FALSE;
|
||||
|
||||
// Variable may be '0' or '1' or not set.
|
||||
if (!variable_get('publishcontent_' . $node->type, FALSE)) {
|
||||
return $access;
|
||||
}
|
||||
|
||||
if (empty($account)) {
|
||||
global $user;
|
||||
$account = $user;
|
||||
}
|
||||
|
||||
foreach (module_invoke_all('publishcontent_publish_access', $node, $account) as $module_access) {
|
||||
if (!is_null($module_access)) {
|
||||
if ($module_access === PUBLISHCONTENT_ACCESS_DENY) {
|
||||
// Anything denying access gets priority.
|
||||
return FALSE;
|
||||
}
|
||||
elseif ($module_access === PUBLISHCONTENT_ACCESS_ALLOW) {
|
||||
// Something grants access.
|
||||
$access = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $access;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_publishcontent_publish_access().
|
||||
*/
|
||||
function publishcontent_publishcontent_publish_access($node, $user) {
|
||||
$access = (user_access('administer nodes')
|
||||
|| user_access('publish any content')
|
||||
|| (user_access('publish own content') && $user->uid == $node->uid)
|
||||
|| (user_access('publish editable content') && (!isset($node->nid) || node_access('update', $node)))
|
||||
|| (user_access('publish own ' . check_plain($node->type) . ' content', $user) && $user->uid == $node->uid)
|
||||
|| user_access('publish any ' . check_plain($node->type) . ' content')
|
||||
|| (user_access('publish editable ' . check_plain($node->type) . ' content') && (!isset($node->nid) || node_access('update', $node)))
|
||||
);
|
||||
|
||||
return $access ? PUBLISHCONTENT_ACCESS_ALLOW : PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if a user has unpublish rights on a node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node object to check against
|
||||
* @param user $account
|
||||
* The user account object to check. Defaults to current user.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if the user has unpublish rights to the node.
|
||||
*/
|
||||
function publishcontent_unpublish_access($node, $account = NULL) {
|
||||
if (empty($account)) {
|
||||
global $user;
|
||||
$account = $user;
|
||||
}
|
||||
|
||||
$access = FALSE;
|
||||
|
||||
foreach (module_invoke_all('publishcontent_unpublish_access', $node, $account) as $module_access) {
|
||||
if (!is_null($module_access)) {
|
||||
if ($module_access === PUBLISHCONTENT_ACCESS_DENY) {
|
||||
// Anything denying access gets priority.
|
||||
return FALSE;
|
||||
}
|
||||
elseif ($module_access === PUBLISHCONTENT_ACCESS_ALLOW) {
|
||||
// Something grants access.
|
||||
$access = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $access;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_publishcontent_unpublish_access().
|
||||
*/
|
||||
function publishcontent_publishcontent_unpublish_access($node, $user) {
|
||||
$access = (user_access('administer nodes')
|
||||
|| user_access('unpublish any content')
|
||||
|| (user_access('unpublish own content') && $user->uid == $node->uid)
|
||||
|| (user_access('unpublish editable content') && (!isset($node->nid) || node_access('update', $node)))
|
||||
|| (user_access('unpublish own ' . check_plain($node->type) . ' content', $user) && $user->uid == $node->uid)
|
||||
|| user_access('unpublish any ' . check_plain($node->type) . ' content')
|
||||
|| (user_access('unpublish editable ' . check_plain($node->type) . ' content') && (!isset($node->nid) || node_access('update', $node)))
|
||||
);
|
||||
|
||||
return $access ? PUBLISHCONTENT_ACCESS_ALLOW : PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_permission().
|
||||
*/
|
||||
function publishcontent_permission() {
|
||||
$perms = array(
|
||||
'publish any content' => array(
|
||||
'title' => t('Publish any content'),
|
||||
),
|
||||
'unpublish any content' => array(
|
||||
'title' => t('Unpublish any content'),
|
||||
),
|
||||
'publish editable content' => array(
|
||||
'title' => t('Publish editable content'),
|
||||
),
|
||||
'unpublish editable content' => array(
|
||||
'title' => t('Unpublish editable content'),
|
||||
),
|
||||
);
|
||||
|
||||
foreach (node_type_get_types() as $type) {
|
||||
// Only show permissions for activated node types.
|
||||
if (isset($type->type) && variable_get('publishcontent_' . $type->type, FALSE)) {
|
||||
$perms['publish any ' . $type->type . ' content'] = array(
|
||||
'title' => t('Publish any @type content', array('@type' => $type->name)));
|
||||
$perms['publish own ' . $type->type . ' content'] = array(
|
||||
'title' => t('Publish own @type content', array('@type' => $type->name)));
|
||||
$perms['publish editable ' . $type->type . ' content'] = array(
|
||||
'title' => t('Publish editable @type content', array('@type' => $type->name)));
|
||||
$perms['unpublish any ' . $type->type . ' content'] = array(
|
||||
'title' => t('Unpublish any @type content', array('@type' => $type->name)));
|
||||
$perms['unpublish own ' . $type->type . ' content'] = array(
|
||||
'title' => t('Unpublish own @type content', array('@type' => $type->name)));
|
||||
$perms['unpublish editable ' . $type->type . ' content'] = array(
|
||||
'title' => t('Unpublish editable @type content', array('@type' => $type->name)));
|
||||
}
|
||||
}
|
||||
return $perms;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to generate change of status message.
|
||||
*/
|
||||
function _publishcontent_get_message($nid, $title, $status) {
|
||||
return ($status) ?
|
||||
t('"@title" [@nid] has been published', array('@title' => $title, '@nid' => $nid)) :
|
||||
t('"@title" [@nid] has been unpublished', array('@title' => $title, '@nid' => $nid));
|
||||
}
|
||||
|
||||
/**
|
||||
* Menu callback for publish / unpublish content actions.
|
||||
*
|
||||
* @param node $node
|
||||
* A node object.
|
||||
*/
|
||||
function publishcontent_toggle_status($node) {
|
||||
// XOR the current status with 1 to get the opposite value.
|
||||
$node->status = $node->status ^ 1;
|
||||
// If this content type specifies that a new revision should be created on
|
||||
// editing, then make sure to respect this option.
|
||||
$node_options = variable_get('node_options_' . $node->type, array());
|
||||
if (in_array('revision', $node_options)) {
|
||||
$node->revision = 1;
|
||||
}
|
||||
|
||||
// Save the status we want to set.
|
||||
$status = $node->status;
|
||||
|
||||
// Try to update the node.
|
||||
node_save($node);
|
||||
|
||||
// Validate the status has changed.
|
||||
if ($status == $node->status) {
|
||||
// Everything went well.
|
||||
drupal_set_message(_publishcontent_get_message($node->nid, $node->title, $node->status));
|
||||
}
|
||||
else {
|
||||
// Prevent the user something went wrong.
|
||||
drupal_set_message(t('The status of the node could not be updated.'), 'error');
|
||||
}
|
||||
|
||||
// Clear the page and block caches.
|
||||
cache_clear_all();
|
||||
|
||||
drupal_goto($_SERVER['HTTP_REFERER']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_form_FORM_ID_alter().
|
||||
*
|
||||
* Allow to use the 'Publishing options' on the edit/add page.
|
||||
*/
|
||||
function publishcontent_form_node_type_form_alter(&$form, &$form_state, $form_id) {
|
||||
// Do not activate this option by default.
|
||||
$form['workflow']['publishcontent'] = array(
|
||||
'#type' => 'checkbox',
|
||||
'#title' => t('Enable publishcontent'),
|
||||
'#default_value' => variable_get('publishcontent_' . $form['#node_type']->type, FALSE),
|
||||
'#description' => t('Display publish or unpublish link for nodes of this type.'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_form_FORM_ID_alter().
|
||||
*
|
||||
* Alter the node edit forms.
|
||||
*/
|
||||
function publishcontent_form_node_form_alter(&$form, &$form_state) {
|
||||
if ($form['#form_id'] == 'node_delete_confirm') {
|
||||
return;
|
||||
}
|
||||
|
||||
$node = $form['#node'];
|
||||
|
||||
if (!variable_get('publishcontent_' . $node->type, FALSE)) {
|
||||
// Publish content is not set or disabled for this content type.
|
||||
return;
|
||||
}
|
||||
|
||||
if (!publishcontent_publish_access($node)) {
|
||||
if (!isset($node->nid)) {
|
||||
// Ensure users without permission to publish can't do so because of the
|
||||
// default setting in the content type. This setting controls the actual
|
||||
// value in $form_state.
|
||||
$form['options']['status']['#default_value'] = 0;
|
||||
// These won't affect $form_state but also need to be updated.
|
||||
$form['#node']->status = 0;
|
||||
$node->status = 0;
|
||||
}
|
||||
if (empty($node->status)) {
|
||||
// Publish content is unavailable for user without publish access.
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (!empty($node->status) && !publishcontent_unpublish_access($node)) {
|
||||
// Publish content is unavailable for user without unpublish access.
|
||||
return;
|
||||
}
|
||||
|
||||
if (_publishcontent_get_method() == PUBLISHCONTENT_METHOD_BUTTON) {
|
||||
_publishcontent_configure_publish_button($form, $form_state);
|
||||
}
|
||||
else {
|
||||
_publishcontent_configure_publish_checkbox($form, $form_state);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add the publish button to the node edit form.
|
||||
*/
|
||||
function _publishcontent_configure_publish_button(&$form, &$form_state) {
|
||||
$node = $form['#node'];
|
||||
|
||||
if (empty($node->nid) || empty($form['actions'])) {
|
||||
// Don't include the publish button on node add forms.
|
||||
return;
|
||||
}
|
||||
|
||||
// Add either the publish or unpublish buttons.
|
||||
$form['actions']['publish'] = empty($node->status) ?
|
||||
publishcontent_render_publish_button() :
|
||||
publishcontent_render_unpublish_button();
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure the node form to include the publish checkbox.
|
||||
*/
|
||||
function _publishcontent_configure_publish_checkbox(&$form, &$form_state) {
|
||||
$form['options']['status']['#access'] = TRUE;
|
||||
if (!empty($form['options']['#access'])) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
$form['options']['#access'] = TRUE;
|
||||
}
|
||||
foreach (element_children($form['options']) as $key) {
|
||||
// If another form has afforded access to a particular option, do not
|
||||
// override that access. Otherwise, disable it.
|
||||
$form['options'][$key]['#access']
|
||||
= isset($form['options'][$key]['#access'])
|
||||
? $form['options'][$key]['#access'] : FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Render publish button.
|
||||
*/
|
||||
function publishcontent_render_publish_button() {
|
||||
return array(
|
||||
'#type' => 'submit',
|
||||
'#access' => TRUE,
|
||||
'#value' => t('Publish'),
|
||||
'#weight' => '30',
|
||||
'#submit' => array('_publishcontent_publish_node'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Render unpublish button.
|
||||
*/
|
||||
function publishcontent_render_unpublish_button() {
|
||||
return array(
|
||||
'#type' => 'submit',
|
||||
'#access' => TRUE,
|
||||
'#value' => t('Unpublish'),
|
||||
'#weight' => '30',
|
||||
'#submit' => array('_publishcontent_unpublish_node'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit handler to publish the node.
|
||||
*/
|
||||
function _publishcontent_publish_node($form, &$form_state) {
|
||||
// Set the node status as published. And that's it.
|
||||
$form_state['values']['status'] = 1;
|
||||
// Use the standard submit function. Do not go custom on me boy.
|
||||
node_form_submit($form, $form_state);
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit handler to unpublish the node.
|
||||
*/
|
||||
function _publishcontent_unpublish_node($form, &$form_state) {
|
||||
// Set the status as unpublished. And there is no more to that.
|
||||
$form_state['values']['status'] = 0;
|
||||
// Use the standard submit function.
|
||||
node_form_submit($form, $form_state);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_views_api().
|
||||
*/
|
||||
function publishcontent_views_api() {
|
||||
return array('api' => 3);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_views_data_alter().
|
||||
*
|
||||
* Add items to the node table that are relevant to publishcontent.
|
||||
*/
|
||||
function publishcontent_views_data_alter(&$data) {
|
||||
$data['node']['publishcontent'] = array(
|
||||
'title' => t('Publish link'),
|
||||
'help' => t('Display a link to publish the node.'),
|
||||
'field' => array(
|
||||
'handler' => 'publishcontent_views_handler_field_node_link',
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the configured publish content method.
|
||||
*/
|
||||
function _publishcontent_get_method() {
|
||||
return variable_get('publishcontent_method', PUBLISHCONTENT_METHOD_TABS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function for hook_menu to get the menu type for the current setup.
|
||||
*/
|
||||
function _publishcontent_get_menutype() {
|
||||
$method = _publishcontent_get_method();
|
||||
$menu_type = MENU_CALLBACK;
|
||||
|
||||
if ($method == PUBLISHCONTENT_METHOD_TABS) {
|
||||
$menu_type = MENU_LOCAL_TASK;
|
||||
}
|
||||
elseif ($method == PUBLISHCONTENT_METHOD_ACTION_LINKS) {
|
||||
$menu_type = MENU_LOCAL_ACTION;
|
||||
}
|
||||
|
||||
return $menu_type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_og_permission().
|
||||
*/
|
||||
function publishcontent_og_permission() {
|
||||
$permissions = array();
|
||||
|
||||
foreach (publishcontent_permission() as $name => $details) {
|
||||
$permissions[$name] = array(
|
||||
'title' => $details['title'],
|
||||
'description' => isset($details['description']) ? $details['description'] : '',
|
||||
'default role' => array(OG_ADMINISTRATOR_ROLE),
|
||||
);
|
||||
}
|
||||
|
||||
return $permissions;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_publishcontent_publish_access().
|
||||
*
|
||||
* Implement on behalf of organic groups.
|
||||
*/
|
||||
function og_publishcontent_publish_access($node, $account) {
|
||||
$access = FALSE;
|
||||
|
||||
foreach (og_get_entity_groups('node', $node) as $entity_type => $og_memberships) {
|
||||
foreach ($og_memberships as $entity_id) {
|
||||
$group_access = !$node->status &&
|
||||
(og_user_access($entity_type, $entity_id, 'administer nodes', $account)
|
||||
|| og_user_access($entity_type, $entity_id, 'publish any content', $account)
|
||||
|| (og_user_access($entity_type, $entity_id, 'publish own content', $account) && $account->uid == $node->uid)
|
||||
|| (og_user_access($entity_type, $entity_id, 'publish editable content', $account) && node_access('update', $node))
|
||||
|| (og_user_access($entity_type, $entity_id, 'publish own ' . check_plain($node->type) . ' content', $account) && $account->uid == $node->uid)
|
||||
|| og_user_access($entity_type, $entity_id, 'publish any ' . check_plain($node->type) . ' content', $account)
|
||||
|| (og_user_access($entity_type, $entity_id, 'publish editable ' . check_plain($node->type) . ' content', $account) && node_access('update', $node))
|
||||
);
|
||||
|
||||
if ($group_access) {
|
||||
$access = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $access ? PUBLISHCONTENT_ACCESS_ALLOW : PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements hook_publishcontent_unpublish_access().
|
||||
*
|
||||
* Implement on behalf of organic groups.
|
||||
*/
|
||||
function og_publishcontent_unpublish_access($node, $account) {
|
||||
$access = FALSE;
|
||||
|
||||
foreach (og_get_entity_groups('node', $node) as $entity_type => $og_memberships) {
|
||||
foreach ($og_memberships as $entity_id) {
|
||||
$group_access = $node->status &&
|
||||
(og_user_access($entity_type, $entity_id, 'administer nodes', $account)
|
||||
|| og_user_access($entity_type, $entity_id, 'unpublish any content', $account)
|
||||
|| (og_user_access($entity_type, $entity_id, 'unpublish own content', $account) && $account->uid == $node->uid)
|
||||
|| (og_user_access($entity_type, $entity_id, 'unpublish editable content') && node_access('update', $node))
|
||||
|| (og_user_access($entity_type, $entity_id, 'unpublish own ' . check_plain($node->type) . ' content', $account) && $account->uid == $node->uid)
|
||||
|| og_user_access($entity_type, $entity_id, 'unpublish any ' . check_plain($node->type) . ' content', $account)
|
||||
|| (og_user_access($entity_type, $entity_id, 'unpublish editable ' . check_plain($node->type) . ' content', $account) && node_access('update', $node))
|
||||
);
|
||||
|
||||
if ($group_access) {
|
||||
$access = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $access ? PUBLISHCONTENT_ACCESS_ALLOW : PUBLISHCONTENT_ACCESS_IGNORE;
|
||||
}
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Views field handler providing a publish, unpublish link.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Field handler to present a link node publish.
|
||||
*/
|
||||
class publishcontent_views_handler_field_node_link extends views_handler_field_node_link {
|
||||
|
||||
/**
|
||||
* Define the field handler constructor.
|
||||
*/
|
||||
function construct() {
|
||||
parent::construct();
|
||||
$this->additional_fields['nid'] = 'nid';
|
||||
$this->additional_fields['type'] = 'type';
|
||||
$this->additional_fields['status'] = 'status';
|
||||
$this->additional_fields['uid'] = 'uid';
|
||||
}
|
||||
|
||||
/**
|
||||
* Define the view option definition.
|
||||
*/
|
||||
function option_definition() {
|
||||
$options = parent::option_definition();
|
||||
$options['publish'] = $options['unpublish'] = array('default' => '', 'translatable' => TRUE);
|
||||
return $options;
|
||||
}
|
||||
|
||||
/**
|
||||
* Define the view option form.
|
||||
*/
|
||||
function options_form(&$form, &$form_state) {
|
||||
parent::options_form($form, $form_state);
|
||||
unset($form['text']);
|
||||
$form['publish'] = array(
|
||||
'#type' => 'textfield',
|
||||
'#title' => t('Text to display for publishing'),
|
||||
'#default_value' => $this->options['publish'],
|
||||
);
|
||||
$form['unpublish'] = array(
|
||||
'#type' => 'textfield',
|
||||
'#title' => t('Text to display for unpublishing'),
|
||||
'#default_value' => $this->options['unpublish'],
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Define the fields query.
|
||||
*/
|
||||
function query() {
|
||||
$this->ensure_my_table();
|
||||
$this->add_additional_fields();
|
||||
}
|
||||
|
||||
/**
|
||||
* Render the field.
|
||||
*/
|
||||
function render_link($node, $values) {
|
||||
// Ensure user has access to edit this node.
|
||||
if (!empty($node->status) && publishcontent_unpublish_access($node)) {
|
||||
$op = 'unpublish';
|
||||
}
|
||||
|
||||
if (empty($node->status) && publishcontent_publish_access($node)) {
|
||||
$op = 'publish';
|
||||
}
|
||||
|
||||
if (isset($op)) {
|
||||
$this->options['alter']['make_link'] = TRUE;
|
||||
$this->options['alter']['path'] = "node/$node->nid/$op/" . drupal_get_token();
|
||||
$this->options['alter']['query'] = drupal_get_destination();
|
||||
$this->options['alter']['link_class'] = 'publishcontent-link publishcontent-' . $op;
|
||||
|
||||
return empty($this->options[$op]) ? t($op) : $this->options[$op];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,731 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Unit tests for Publish Content module.
|
||||
*/
|
||||
|
||||
/**
|
||||
* We test to ensure we are not messing up with the default Drupal
|
||||
* access for view node i.e. a owner of a node can view it even if unpublished.
|
||||
*/
|
||||
abstract class PublishContentWebTestBase extends DrupalWebTestCase {
|
||||
|
||||
/**
|
||||
* Perform a GET operation on a node.
|
||||
*
|
||||
* This will check the response to access some operation via
|
||||
* the URL of a node. In the case of 'publish' or 'unpublish'
|
||||
* it will first visit the view of a node so that the relevant
|
||||
* tabs can be generated.
|
||||
*
|
||||
* @param int $nid
|
||||
* The node nid
|
||||
* @param string $op
|
||||
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
||||
* @param int $expected_response
|
||||
* The expexted response code. If the user should not be able to
|
||||
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
||||
* 200.
|
||||
* @param string $msg
|
||||
* (optional) An assertion log message.
|
||||
*/
|
||||
public abstract function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '');
|
||||
|
||||
/**
|
||||
* Allow content type to be used with publish content.
|
||||
*/
|
||||
public function enablePublishContentForContentType($types) {
|
||||
if (!is_array($types)) {
|
||||
$types = array($types);
|
||||
}
|
||||
|
||||
foreach ($types as $type) {
|
||||
variable_set('publishcontent_' . $type, TRUE);
|
||||
}
|
||||
|
||||
// Rebuild SimpleTests permissions cache.
|
||||
$this->checkPermissions(array(), TRUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the status of a given node.
|
||||
*
|
||||
* @param int $nid
|
||||
* The node nid to check
|
||||
* @param int $status
|
||||
* Either 1 for published or 0 for unpublished
|
||||
*/
|
||||
public function assertNodeStatus($nid, $status, $msg = '') {
|
||||
$node = node_load($nid, NULL, TRUE);
|
||||
$msg = !empty($msg) ? $msg : t('Node status is @actual, expecting @expected', array('@actual' => $node->status, '@expected' => $status));
|
||||
$this->assertEqual($node->status, $status, $msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the status of a node.
|
||||
*
|
||||
* @param node|int $node
|
||||
* A loaded node object or node nid
|
||||
* @param int $status
|
||||
* The status to set, 1 for published, 0 for unpublished.
|
||||
*/
|
||||
public function setNodeStatus($node, $status, $msg = '') {
|
||||
$node = is_object($node) ? $node : node_load($node);
|
||||
if ($node->status != $status) {
|
||||
$node->status = $status;
|
||||
node_save($node);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check the current user session forbids publish of a given node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node object to test against.
|
||||
*/
|
||||
public function assertCurrentUserCannotPublish($node) {
|
||||
$status = $node->status;
|
||||
$username = $this->loggedInUser->name;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot publish the published node');
|
||||
$this->assertNodeStatus($node->nid, 1, 'node should be still published');
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
||||
$this->setNodeStatus($node, 0);
|
||||
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot publish the unpublished node');
|
||||
$this->assertNodeStatus($node->nid, 0, 'node should be still unpublished');
|
||||
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check the current user session cannot unpublish a given node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node object to test against.
|
||||
*/
|
||||
public function assertCurrentUserCannotUnpublish($node) {
|
||||
$status = $node->status;
|
||||
$username = $this->loggedInUser->name;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot unpublish the published node');
|
||||
$this->assertNodeStatus($node->nid, 1, 'node should be still published');
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
||||
$this->setNodeStatus($node, 0);
|
||||
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot unpublish an unpublished node');
|
||||
$this->assertNodeStatus($node->nid, 0, 'node should be still unpublished');
|
||||
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check the current user session can publish a given node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node object to test against.
|
||||
*/
|
||||
public function assertCurrentUserCanPublish($node) {
|
||||
$status = $node->status;
|
||||
$username = $this->loggedInUser->name;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->assertNodeOperationAccess($node->nid, 'publish', 403, $username . ' cannot access the publish callback for a node which is already published.');
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the published node');
|
||||
$this->setNodeStatus($node, 0);
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view unpublished node');
|
||||
$this->assertNodeOperationAccess($node->nid, 'publish', 200, $username . ' can access publish callback on an unpublished node');
|
||||
$this->assertNodeStatus($node->nid, 1, 'node should now be published');
|
||||
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check the current user session can unpublish a node.
|
||||
*
|
||||
* @param node $node
|
||||
* The node to test against.
|
||||
*/
|
||||
public function assertCurrentUserCanUnpublish($node) {
|
||||
$status = $node->status;
|
||||
$username = $this->loggedInUser->name;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->assertNodeOperationAccess($node->nid, 'unpublish', 200, $username . ' can access unpublish callback on a published node');
|
||||
$this->assertNodeStatus($node->nid, 0, 'Node should now be unpublished');
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 200, $username . ' can view the unpublished node.');
|
||||
$this->assertNodeOperationAccess($node->nid, 'unpublish', 403, $username . ' cannot access the unpublish callback of an unpublished node');
|
||||
$this->assertNodeStatus($node->nid, 0, 'Node should still be unpublished');
|
||||
$this->setNodeStatus($node, $status, 'Reset the nodes status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the current user can publish a node from the listing test page.
|
||||
*/
|
||||
public function assertCanPublishFromLinksPage($node) {
|
||||
$status = $node->status;
|
||||
$this->setNodeStatus($node, 0, 'Start test with an unpublished node');
|
||||
$this->drupalGet('publishcontent-links');
|
||||
$this->assertResponse(200);
|
||||
$this->assertLink('publish-' . $node->nid);
|
||||
$this->assertNoLink('unpublish-' . $node->nid);
|
||||
$this->clickLink('publish-' . $node->nid);
|
||||
$this->assertResponse(200);
|
||||
$this->assertNodeStatus($node->nid, 1);
|
||||
$this->setNodeStatus($node, $status, 'Reset status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the current user cannot publish a node from the listing test page.
|
||||
*/
|
||||
public function assertCannotPublishFromLinksPage($node) {
|
||||
$status = $node->status;
|
||||
$this->setNodeStatus($node, 0, 'Start test with an unpublished node');
|
||||
$this->drupalGet('publishcontent-links');
|
||||
$this->assertResponse(200);
|
||||
$this->assertNoLink('publish-' . $node->nid);
|
||||
$this->assertNoLink('unpublish-' . $node->nid);
|
||||
$this->setNodeStatus($node, $status, 'Reset status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the current user can unpublish a node from the listing test page.
|
||||
*/
|
||||
public function assertCanUnpublishFromLinksPage($node) {
|
||||
$status = $node->status;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->drupalGet('publishcontent-links');
|
||||
$this->assertResponse(200);
|
||||
$this->assertLink('unpublish-' . $node->nid);
|
||||
$this->assertNoLink('publish-' . $node->nid);
|
||||
$this->clickLink('unpublish-' . $node->nid);
|
||||
$this->assertResponse(200);
|
||||
$this->assertNodeStatus($node->nid, 0);
|
||||
$this->setNodeStatus($node, $status, 'Reset status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the current user cannot unpublish a node from the listing test page.
|
||||
*/
|
||||
public function assertCannotUnpublishFromLinksPage($node) {
|
||||
$status = $node->status;
|
||||
$this->setNodeStatus($node, 1, 'Start test with a published node');
|
||||
$this->drupalGet('publishcontent-links');
|
||||
$this->assertResponse(200);
|
||||
$this->assertNoLink('publish-' . $node->nid);
|
||||
$this->assertNoLink('unpublish-' . $node->nid);
|
||||
$this->setNodeStatus($node, $status, 'Reset status');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check no publish permission by node owner.
|
||||
*/
|
||||
public function testNoPublishPermissionByOwner() {
|
||||
$web_user = $this->drupalCreateUser(array('access content'));
|
||||
$this->drupalLogin($web_user);
|
||||
|
||||
$node = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => 'page',
|
||||
'uid' => $web_user->uid,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->assertCurrentUserCannotPublish($node);
|
||||
$this->assertCurrentUserCannotUnpublish($node);
|
||||
|
||||
$this->setNodeStatus($node, 0);
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 403, 'Node is not accessible by its owner when unpublished.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check publishcontent module does not interfere with the normal Drupal.
|
||||
*/
|
||||
public function testNoPermissionAndNotOwner() {
|
||||
$node = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => 'page',
|
||||
'uid' => 0,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalLogin($this->drupalCreateUser(array('access content')));
|
||||
|
||||
$this->assertCurrentUserCannotPublish($node);
|
||||
$this->assertCurrentUserCannotUnpublish($node);
|
||||
|
||||
$this->setNodeStatus($node, 0);
|
||||
$this->assertNodeOperationAccess($node->nid, 'view', 403, 'Node is not viewable by non owner when unpublished by a user without publish or unpublish permissions');
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the combination of publish but not unpublish permissions.
|
||||
*/
|
||||
public function testPublishNotUnpublish() {
|
||||
$type = 'page';
|
||||
$this->enablePublishContentForContentType($type);
|
||||
|
||||
$web_user = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish editable ' . $type . ' content',
|
||||
'view own unpublished content',
|
||||
'edit own ' . $type . ' content',
|
||||
));
|
||||
|
||||
$this->drupalLogin($web_user);
|
||||
|
||||
$node = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => $web_user->uid,
|
||||
'status' => 0,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalGet('node/' . $node->nid . '/edit');
|
||||
$this->assertResponse(200);
|
||||
|
||||
$this->assertCurrentUserCanPublish($node);
|
||||
$this->assertCurrentUserCannotUnpublish($node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the combination of unpublish but not publish.
|
||||
*/
|
||||
public function testNotPublishUnpublish() {
|
||||
$type = 'page';
|
||||
$this->enablePublishContentForContentType($type);
|
||||
|
||||
$web_user = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'unpublish any ' . $type . ' content',
|
||||
'view own unpublished content',
|
||||
'edit own ' . $type . ' content',
|
||||
));
|
||||
$this->drupalLogin($web_user);
|
||||
|
||||
$node = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => $web_user->uid,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->assertCurrentUserCannotPublish($node);
|
||||
$this->assertCurrentUserCanUnpublish($node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the combination of both publish and unpublish.
|
||||
*/
|
||||
public function testPublishUnpublish() {
|
||||
$type = 'page';
|
||||
$this->enablePublishContentForContentType($type);
|
||||
|
||||
$web_user_1 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'view own unpublished content',
|
||||
'edit any ' . $type . ' content',
|
||||
'publish any content',
|
||||
));
|
||||
|
||||
$node1 = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => $web_user_1->uid,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalLogin($web_user_1);
|
||||
$this->assertCurrentUserCanPublish($node1);
|
||||
$this->assertCurrentUserCannotUnpublish($node1);
|
||||
|
||||
$web_user_2 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'view own unpublished content',
|
||||
'edit any ' . $type . ' content',
|
||||
'unpublish any content',
|
||||
));
|
||||
|
||||
$node2 = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => $web_user_2->uid,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalLogin($web_user_2);
|
||||
$this->assertCurrentUserCannotPublish($node2);
|
||||
$this->assertCurrentUserCanUnpublish($node2);
|
||||
|
||||
$web_user_3 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'view own unpublished content',
|
||||
'edit any ' . $type . ' content',
|
||||
'publish any content',
|
||||
'unpublish any content',
|
||||
));
|
||||
|
||||
$node3 = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => $web_user_3->uid,
|
||||
'status' => 1,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalLogin($web_user_3);
|
||||
$this->assertCurrentUserCanPublish($node3);
|
||||
$this->assertCurrentUserCanUnpublish($node3);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test basic publish ability using the publishcontent_test module.
|
||||
*/
|
||||
public function testBasicPublishCallback() {
|
||||
$type = 'page';
|
||||
$this->enablePublishContentForContentType(array($type, 'article'));
|
||||
|
||||
$web_user_1 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish any content',
|
||||
));
|
||||
|
||||
$web_user_2 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'unpublish any content',
|
||||
));
|
||||
|
||||
$web_user_3 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish any content',
|
||||
'unpublish any content',
|
||||
));
|
||||
|
||||
$web_user_4 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish any ' . $type . ' content',
|
||||
));
|
||||
|
||||
$web_user_5 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'unpublish any ' . $type . ' content',
|
||||
));
|
||||
|
||||
$web_user_6 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish any ' . $type . ' content',
|
||||
'unpublish any ' . $type . ' content',
|
||||
));
|
||||
|
||||
$web_user_7 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'publish any article content',
|
||||
'unpublish any article content',
|
||||
));
|
||||
|
||||
$node = $this->drupalCreateNode(
|
||||
array(
|
||||
'type' => $type,
|
||||
'uid' => 1,
|
||||
'status' => 0,
|
||||
)
|
||||
);
|
||||
|
||||
$this->drupalLogin($web_user_1);
|
||||
$this->assertCanPublishFromLinksPage($node, 'Someone with publish any content can publish page node');
|
||||
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with publish any content cannot unpublish page node');
|
||||
|
||||
$this->drupalLogin($web_user_2);
|
||||
$this->assertCannotPublishFromLinksPage($node, 'Someone with unpublish any content cannot publish page node');
|
||||
$this->assertCanUnpublishFromLinksPage($node, 'Someone with unpublish any content can unpublish page node');
|
||||
|
||||
$this->drupalLogin($web_user_3);
|
||||
$this->assertCanPublishFromLinksPage($node, 'Someone with publish and unpublish any content can publish page node');
|
||||
$this->assertCanUnpublishFromLinksPage($node, 'Someone with publish and unpublish any content can unpublish page node');
|
||||
|
||||
$this->drupalLogin($web_user_4);
|
||||
$this->assertCanPublishFromLinksPage($node, 'Someone with publish any page nodes can publish a page node');
|
||||
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with publish any page nodes cannot unpublish page node');
|
||||
|
||||
$this->drupalLogin($web_user_5);
|
||||
$this->assertCannotPublishFromLinksPage($node, 'Someone with unpublish any page node cannot publish a page node');
|
||||
$this->assertCanUnpublishFromLinksPage($node, 'Someone with unpublish any page node can unpublish a page node');
|
||||
|
||||
$this->drupalLogin($web_user_6);
|
||||
$this->assertCanPublishFromLinksPage($node, 'Someone with publish and unpublish any page node can publish a page node');
|
||||
$this->assertCanUnpublishFromLinksPage($node, 'Someone with publish and unpublish any page node can unpublish a page node');
|
||||
|
||||
$this->drupalLogin($web_user_7);
|
||||
$this->assertCannotPublishFromLinksPage($node, 'Someone with publish any article content cannot publish page content');
|
||||
$this->assertCannotUnpublishFromLinksPage($node, 'Someone with unpublish any article content cannot unpublish page content');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Test permissions with the tab method.
|
||||
*/
|
||||
class PublishContentTabTests extends PublishContentWebTestBase {
|
||||
|
||||
/**
|
||||
* Drupal SimpleTest method: return metadata about the test.
|
||||
*/
|
||||
public static function getInfo() {
|
||||
return array(
|
||||
'name' => t('Publish Content: Tab Tests'),
|
||||
'description' => t('Executes test suite for Publish Content module with the tab method.'),
|
||||
'group' => t('Publish Content'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test setup instructions.
|
||||
*/
|
||||
public function setUp() {
|
||||
parent::setUp('publishcontent', 'publishcontent_test');
|
||||
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_TABS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform a GET operation on a node.
|
||||
*
|
||||
* This will check the response to access some operation via
|
||||
* the URL of a node. In the case of 'publish' or 'unpublish'
|
||||
* it will first visit the view of a node so that the relevant
|
||||
* tabs can be generated.
|
||||
*
|
||||
* @param int $nid
|
||||
* The node nid
|
||||
* @param string $op
|
||||
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
||||
* @param int $expected_response
|
||||
* The expexted response code. If the user should not be able to
|
||||
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
||||
* 200.
|
||||
* @param string $msg
|
||||
* (optional) An assertion log message.
|
||||
*/
|
||||
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
||||
if (in_array($op, array('publish', 'unpublish'))) {
|
||||
$tab_link_text = ucfirst($op);
|
||||
|
||||
// Visit the edit page first to generate the tab.
|
||||
$this->drupalGet("node/{$nid}");
|
||||
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
||||
if ($view_response != 200) {
|
||||
$msg .= t('Could not view the node. Response code: @response', array('@response' => $view_response));
|
||||
$this->assert($expected_response == $view_response, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check the tab exists.
|
||||
$links = $this->xpath('//a[normalize-space(text())=:label]', array(':label' => $tab_link_text));
|
||||
if (!isset($links[0])) {
|
||||
// No tab.
|
||||
$msg .= t('Could not find a tab called @tab', array('@tab' => $tab_link_text));
|
||||
$this->assert($expected_response != 200, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Now visit the tab.
|
||||
$this->clickLink($tab_link_text);
|
||||
|
||||
$node = node_load($nid);
|
||||
|
||||
if ($op == 'publish') {
|
||||
$this->assertText(_publishcontent_get_message($node->nid, $node->title, TRUE),
|
||||
'Publish content message is visible.');
|
||||
}
|
||||
else {
|
||||
$this->assertText(_publishcontent_get_message($node->nid, $node->title, FALSE),
|
||||
'Unpublish message is visible.');
|
||||
}
|
||||
}
|
||||
else {
|
||||
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
||||
$this->drupalGet($url);
|
||||
}
|
||||
|
||||
$this->assertResponse($expected_response, $msg);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Test permissions with the button method.
|
||||
*/
|
||||
class PublishContentButtonTests extends PublishContentWebTestBase {
|
||||
|
||||
/**
|
||||
* Drupal SimpleTest method: return metadata about the test.
|
||||
*/
|
||||
public static function getInfo() {
|
||||
return array(
|
||||
'name' => t('Publish Content: Button Tests'),
|
||||
'description' => t('Executes test suite for Publish Content module with the button method.'),
|
||||
'group' => t('Publish Content'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test setup instructions.
|
||||
*/
|
||||
public function setUp() {
|
||||
parent::setUp('publishcontent', 'publishcontent_test');
|
||||
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_BUTTON);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform a GET operation on a node.
|
||||
*
|
||||
* This will check the response to access some operation via
|
||||
* the URL of a node. In the case of 'publish' or 'unpublish'
|
||||
* it will first visit the view of a node so that the relevant
|
||||
* tabs can be generated.
|
||||
*
|
||||
* @param int $nid
|
||||
* The node nid
|
||||
* @param string $op
|
||||
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
||||
* @param int $expected_response
|
||||
* The expexted response code. If the user should not be able to
|
||||
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
||||
* 200.
|
||||
* @param string $msg
|
||||
* (optional) An assertion log message.
|
||||
*/
|
||||
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
||||
if (in_array($op, array('publish', 'unpublish'))) {
|
||||
$button_text = t(ucfirst($op));
|
||||
|
||||
// Visit the edit page first to generate the tab.
|
||||
$this->drupalGet("node/{$nid}/edit");
|
||||
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
||||
if ($view_response != 200) {
|
||||
$msg .= t('Could not view the node. Response code: @response', array('@response' => $view_response));
|
||||
$this->assert($expected_response == $view_response, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Find the button.
|
||||
$buttons = $this->xpath('//input[@value=:label]', array(':label' => $button_text));
|
||||
if (!isset($buttons[0])) {
|
||||
// No button.
|
||||
$msg .= t('Could not find a button called @button', array('@button' => $button_text));
|
||||
$this->assert($expected_response != 200, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Submit the form.
|
||||
$this->drupalPost("node/{$nid}/edit", array(), $button_text);
|
||||
}
|
||||
else {
|
||||
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
||||
$this->drupalGet($url);
|
||||
}
|
||||
|
||||
$this->assertResponse($expected_response, $msg);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test permissions with the tab method.
|
||||
*/
|
||||
class PublishContentCheckboxTests extends PublishContentWebTestBase {
|
||||
|
||||
/**
|
||||
* Drupal SimpleTest method: return metadata about the test.
|
||||
*/
|
||||
public static function getInfo() {
|
||||
return array(
|
||||
'name' => t('Publish Content: Checkbox Tests'),
|
||||
'description' => t('Executes test suite for Publish Content module with the checkbox method.'),
|
||||
'group' => t('Publish Content'),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test setup instructions.
|
||||
*/
|
||||
public function setUp() {
|
||||
parent::setUp('publishcontent', 'publishcontent_test');
|
||||
variable_set('publishcontent_method', PUBLISHCONTENT_METHOD_NONE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform a GET operation on a node.
|
||||
*
|
||||
* This will check the response to access some operation via
|
||||
* the URL of a node. In the case of 'publish' or 'unpublish'
|
||||
* it will first visit the view of a node so that the relevant
|
||||
* tabs can be generated.
|
||||
*
|
||||
* @param int $nid
|
||||
* The node nid
|
||||
* @param string $op
|
||||
* An operation such as 'view', 'edit', 'publish', 'unpublish'
|
||||
* @param int $expected_response
|
||||
* The expexted response code. If the user should not be able to
|
||||
* see the 'publish' or 'unpublish' tabs, set this to 403, otherwise
|
||||
* 200.
|
||||
* @param string $msg
|
||||
* (optional) An assertion log message.
|
||||
*/
|
||||
public function assertNodeOperationAccess($nid, $op, $expected_response, $msg = '') {
|
||||
if (in_array($op, array('publish', 'unpublish'))) {
|
||||
|
||||
// Visit the edit page first to check for the published checkbox.
|
||||
$this->drupalGet("node/{$nid}/edit");
|
||||
$view_response = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
|
||||
if ($view_response != 200) {
|
||||
$msg .= t('Could not edit the node. Response code: @response', array('@response' => $view_response));
|
||||
$this->assert($expected_response == $view_response, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check the checkbox exists.
|
||||
$elements = $this->xpath('//input[@id=:id]', array(':id' => 'edit-status'));
|
||||
if (!isset($elements[0])) {
|
||||
// No checkboxes.
|
||||
$msg .= t('Published status checkbox is not accessible.');
|
||||
$this->assert($expected_response != 200, $msg);
|
||||
return;
|
||||
}
|
||||
|
||||
// At this point the response code for checkboxes is irrelevant, if
|
||||
// they can access the edit page and see the checkbox, they can edit it.
|
||||
$expected_response = 200;
|
||||
|
||||
// Tick or untick the published checkbox and submit the form.
|
||||
$edit_status = ($op == 'publish');
|
||||
$this->drupalPost("node/{$nid}/edit", array('status' => $edit_status), t('Save'));
|
||||
}
|
||||
else {
|
||||
$url = $op == 'view' ? "node/{$nid}" : "node/$nid/$op";
|
||||
$this->drupalGet($url);
|
||||
}
|
||||
|
||||
$this->assertResponse($expected_response, $msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test access to the node add page is working.
|
||||
*/
|
||||
public function testAccessNodeAdd() {
|
||||
$type = 'page';
|
||||
$this->enablePublishContentForContentType($type);
|
||||
|
||||
$web_user_1 = $this->drupalCreateUser(array(
|
||||
'access content',
|
||||
'view own unpublished content',
|
||||
'create ' . $type . ' content',
|
||||
'publish editable content',
|
||||
'unpublish editable content',
|
||||
));
|
||||
|
||||
$this->drupalLogin($web_user_1);
|
||||
$this->drupalGet('node/add/' . $type);
|
||||
$this->assertResponse(200);
|
||||
$this->assertFieldChecked('edit-status', t('Ensure the publish checkbox is available.'));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
name = Publish Content Test Module
|
||||
description = "Provdes a callback which lists all nodes with publish unpublish links for testing callbacks"
|
||||
core = 7.x
|
||||
package = Testing
|
||||
version = VERSION
|
||||
hidden = TRUE
|
||||
|
||||
; Information added by Drupal.org packaging script on 2014-02-25
|
||||
version = "7.x-1.3"
|
||||
core = "7.x"
|
||||
project = "publishcontent"
|
||||
datestamp = "1393372405"
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* A dummy module for listing all nodes with their publish, unpublish
|
||||
* callback links to test permissions with.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Implements hook_menu().
|
||||
*/
|
||||
function publishcontent_test_menu() {
|
||||
$items = array();
|
||||
|
||||
$items['publishcontent-links'] = array(
|
||||
'title' => 'Node access test',
|
||||
'page callback' => 'publishcontent_test_nodes',
|
||||
'access arguments' => array('access content'),
|
||||
'type' => MENU_SUGGESTED_ITEM,
|
||||
);
|
||||
|
||||
return $items;
|
||||
}
|
||||
|
||||
/**
|
||||
* Menu callback.
|
||||
*
|
||||
* List all nodes on the site with publish, unpublish links.
|
||||
*/
|
||||
function publishcontent_test_nodes() {
|
||||
$output = '';
|
||||
$query = new EntityFieldQuery();
|
||||
$result = $query->entityCondition('entity_type', 'node')
|
||||
->execute();
|
||||
|
||||
if (!empty($result['node'])) {
|
||||
|
||||
$output .= '<ul>';
|
||||
|
||||
foreach (node_load_multiple(array_keys($result['node'])) as $node) {
|
||||
$op = '';
|
||||
|
||||
if (empty($node->status) && publishcontent_publish_access($node)) {
|
||||
$op = 'publish';
|
||||
}
|
||||
elseif (!empty($node->status) && publishcontent_unpublish_access($node)) {
|
||||
$op = 'unpublish';
|
||||
}
|
||||
else {
|
||||
continue;
|
||||
}
|
||||
|
||||
$output .= '<li>' . $node->title . ' ' . l("{$op}-{$node->nid}", "node/{$node->nid}/{$op}/" . drupal_get_token(), array('query' => drupal_get_destination())) . '</li>';
|
||||
}
|
||||
|
||||
$output .= '</ul>';
|
||||
}
|
||||
|
||||
return $output;
|
||||
}
|
||||
Reference in New Issue
Block a user