WordPress Kundenbereich Part 2 – Dateien an eine Gruppe von Kunden veröffentlichen
Dies ist der 2. Teil des Tutorials „In WordPress mit Plugins einen geschützten Kundenbereich anlegen (Part 1)“ und baut darauf auf.
Use Case: Bestimmte Dateien sollen auch an alle registrierten Kunden oder eine vorher definierte Gruppe von Kunden in einem Arbeitsschritt veröffentlicht werden
Das aktuelle Setup des Kundenbereichs ermöglicht bisher das gezielte Veröffentlichen von Privaten Dateien an einzelne registrierte Kunden. Ein nahe liegender Anwendungsfall kann sein, dass einzelne Dateien allen registrierten Kunden zugänglich gemacht werden, man nehme das Beispiel eines allgemeinen Rundschreibens. Dies ließe sich natürlich auch über ein Newsletter Plugin lösen, die Anforderungen sind hier allerding, dass dies als abrufbare Datei (z.B. *.pdf) zentral im Kundenbereich aufzufinden sei.
Weiterhin sollen einzelne Dateien nur einer vorher definierten Gruppe von Kunden zugänglich gemacht werden. Viele Szenarien würden hier greifen: Abteilungen in einem Unternehmen, Schulklassen, Kaffeekränzchen. Teilgruppen von Kunden, die für den Anbieter aus beliebigen Gründen zusammengefasst werden sollen und alle Zugriff auf ein Dokument / Datei haben sollen.
Bisher lässt sich das mit dem aktuellen Setup vom „Customer Area“ Plugin als Fleißarbeit lösen, indem man allen Mitgliedern der Gruppe bzw. allen registrierten Kunden (s.o.) einzeln die entsprechende Datei (Dokument) zuweist und veröffentlicht. Das ist bei X Kunden X mal der gleiche Arbeitsschritt und kann sehr schnell in einem enormen Zeitaufwand enden.
Mit einem Arbeitsschritt soll also eine Datei X Kunden zugänglich gemacht werden.
Es gibt hierfür von den Entwicklern des „Customer Area“ Plugins entsprechende kostenpflichtige Add-Ons, die dies bewerkstelligen.
Eine kostenlose Lösung mit frei verfügbaren WP Plugins und ein wenig Arbeitsaufwand ist aber auch kein Problem.
WP Groups Plugin
Um registrierte WP User zu gruppieren gibt es ein fertiges Plugin „Groups“.
Dies wird einfach über das WP Backend installiert und aktiviert und man erhält einen zusätzlichen Menue-Punkt „Groups“.
Alle registrierten WP Benutzer (zu denen ja auch die Kunden gehören) werden automatisch einer vordefinierten Gruppe zugeordnet, die „registered“ benannt ist. Dies kann man prinzipiell so belassen, oder umbenennen und anpassen, erfüllt aber schon mal das Kriterium des Use Cases „Alle Kunden“, was ja auch eine Gruppierung ist.
Man kann unter dem Menupunkt „Groups“ -> „Groups“ eine Übersicht aller aktuell im System angelegten Gruppen finden, bzw. auch eine neue Gruppe definieren, indem man auf den Button „New Group“ klickt.
Anlegen von Gruppen
Die Eingabemaske zum Anlegen einer neuen Gruppe ist recht übersichtlich und auf das Wesentliche beschränkt. Der neu zu erstellenden Gruppe wird zunächst ein Name zugewiesen, man kann eine übergeordnete Parent-Gruppe angeben, vermutlich mit Vererbung von Rechten und Eigenschaften. Eine Text Area für beschreibenden Text ist selbsterklärend und unter „Capabilities“ können der Gruppe einzelne oder mehrere Berechtigungen aus dem Gesamtkontext der WordPress User Roles zugewiesen werden.
Um alle verfügbaren Berechtigungen einzusehen, oder aber auch um den vordefinierten User Roles in WordPress bestimmte (z.B. auch für einzelne Plugins fehlende) Berechtigungen einzuräumen, empfiehlt sich ein Plugin wie z.B. „User Role Editor“ oder ähnliche.
Zu Testzwecken bleibt dies erstmal ungenutzt, da alle Kunden über Ihre gemeinsame User Role „Subscriber“ (bzw. „Abonennt“) in ihren Berechtigungen im System festgelegt sind und es lediglich um eine Zusammenfassende Gruppierung gehen soll, nicht die Erweiterung oder Einschränkung von Berechtigungen. Dafür könnte man auch eine neue User Role mit entsprechenden Rechten definieren und allen Kunden zuweisen, bzw. als Default bei der Registrierung festlegen.
Es werden erstmal drei Testgruppen angelegt („test-gruppe-1“, „test-gruppe-2“, „test-gruppe-3“). Diese können dann im nächsten Schritt verschiedenen Test-Usern zugewiesen werden.
User in Gruppen zusammenfassen
Wir gehen zunächst von dem Fall aus, das existierende oder neue User von einem Administrator per Hand in verschiedene Gruppen zusammengefasst werden. Dies lässt sich zwar bestimmt auch automatisieren und per Default bei einer Neuregistrierung zuweisen, ist hier aber nicht erforderlich. Es ist auch ein einmaliger Vorgang und vielleicht gehört auch nicht jeder User / Kunde automatisch einer Gruppe an.
Im Menüpunkt „Benutzer“->“Alle Benutzer“ findet sich nach der Installation und Aktivierung des Plugins „Groups“ eine weitere Spalte „“. Weiterhin lassen sich mehrere Benutzer in der Übersicht per Häkchen selektieren und über die neue Bulk Action „Group Actions“ einer Gruppe zuweisen oder aus ihr entfernen.
Im vorliegenden Beispiel gibt es 5 Test-User, die nun verschiedenen Gruppen zugewiesen werden können, auch mit Überschneidungen (Also dass Kunden z.B. mehreren Gruppen angehören können).
Zunächst sind alle User wie oben beschrieben Teil der Gruppe „Registered“, die man auch umbenennen könnte in „Alle“ oder „Registrierte User“ o.Ä.
Neuangelegte Kunden wie auch selbst-registrierte Neukunden sind im vorliegenden Szenario erstmal freizuschalten, was über das Plugin „Confirm User Registration“ gelöst wurde.
In der Gesamtübersicht aller registrierten Benutzer im WordPress werden nun die neuen Test User selektiert und zunächst mal einer Gruppe zugewiesen, z.B. „Test Gruppe 1“.
Die Gruppe, der die User angehören sollen, wird über im Drop Down Menue „Choose Group…“ rechts über der Benutzer Übersicht ausgewählt. Hier können auch (nacheinander) mehrere Gruppen direkt festgelegt werden. Dann noch unter „Group Action“ den Menuepunkt „Add to Group“ auswählen, auf den „Apply“ Button klicken, fertig.
Alle Test User wurden der Test Gruppe 1 zugewiesen, die Test User „test-user-1“ und „test-user-2“ der Test Gruppe 2 und die Test User „test-user-2“, „test-user-3“ und „test-user-4“ der Test Gruppe 3.
Nötige Erweiterung des Plugins „Customer Area“
Somit wurde von der Gruppenzugehörigkeit der User her schon mal ein halbwegs realistisches Test-Szenario geschaffen. Im Kundenbereich selbst lässt sich im Ausgangszustand jedoch nach wie vor nur ein einzelner Benutzer als „Owner“ bzw. Empfänger / Besitzer eines zu veröffentlichenden Dokument / Datei oder Seite festlegen.
Im Programmcode des Plugins „Customer Area“ folgende Datei in einem Editor wie Notepad++ öffnen, oder direkt im WordPress in der Plugin Übersicht bei „Customer Area“ (bzw. mit der überarbeiteten language Datei ist es hier „Kundenbereich“).
Das zu bearbeitende Element aus der Backend-Ansicht, wo beim Erstellen einer neuen Privaten Datei bzw. „Privaten Seite“ festgelegt wird, wem diese zuzuordnen ist, findet sich im WordPress plugins verzeichnis unter :
\wp-content\plugins\customer-area\includes\core-addons\post-owner\post-owner-addon.class.php
Hier ist in der Function get_owner_types() folgende Zeile zu ändern:
$this->owner_types = apply_filters('cuar/core/ownership/owner-types', array( 'usr' => __('User', 'cuar') ) );
muss ergänzt werden um zwei weitere Typen, hier genannt „group“ und „role“:
$this->owner_types = apply_filters('cuar/core/ownership/owner-types', array( 'usr' => __('User', 'cuar'), 'group' => __('Group','cuar'), 'role' => __('Role','cuar') ) );
Diese beiden neuen owner-types müssen im Plugin noch entsprechende Actions zugewiesen werden. Dies geschieht in der function run_addon( $plugin ), wo hinter der Zeile
add_action('cuar/core/ownership/printable-owners?owner-type=usr', array( &$this, 'get_printable_owners_for_type_usr'), 10 );
noch zwei weitere hinzuzufügen sind:
add_action('cuar/core/ownership/printable-owners?owner-type=group', array( &$this, 'get_printable_owners_for_type_group'), 10 );
add_action('cuar/core/ownership/printable-owners?owner-type=role', array( &$this, 'get_printable_owners_for_type_role'), 10 );
Hier werden auch schon direkt zwei neue Funktionsnamen registriert, die noch anzulegen sind:
get_printable_owners_for_type_group() get_printable_owners_for_type_role()
Diese sind analog zur vorhandenen Funktion get_printable_owners_for_type_usr() und können der Übersichtlichkeit direkt dahinter eingefügt werden
/**
* Print a select field with all groups
* @param unknown $field_id
* @param unknown $current_owner_type
* @param unknown $current_owner_id
*/
public function get_printable_owners_for_type_group( $in ) {
$all_groups = Groups_Group::get_groups();
foreach ( $all_groups as $g ) {
$out[ $g->group_id ] = $g->name;
}
return $out;
}
/**
* Print a select field with all roles
* @param unknown $field_id
* @param unknown $current_owner_type
* @param unknown $current_owner_id
*/
public function get_printable_owners_for_type_role( $in ) {
global $wp_roles;
$all_roles = $wp_roles->get_names();
$out = $in;
foreach ( $all_roles as $r ) {
$out[ $r->ID ] = $r->display_name;
}
return $roles;
}
Dadurch erhält man in der Box „Assignment“ unter „Kundenbereich“->“Neue private Datei“ eine erweiterte Auswahlmöglichkeit, in der die im WordPress angelegten Gruppen und auch die User Roles als Owner der zu erstellenden Datei selektierbar sind.
Korrekte Ausgabe des Owner Types im Backend (Übersicht) und Frontend
In der Übersicht der privaten Dateien erhält man in der Spalte „Inhaber“ (bzw. Owner) der Datei aber bisher keine korrekte Zuordnung zu den neuen Owner Types, sondern lediglich einen Eintrag ‚?‘. Ein Blick in den Source Code der Datei post-owner-addon.class.php zeigt schnell warum:
In der Funktion save_post_owners() findet sich lediglich eine Abfrage darauf, ob der owner_type vom Typ „usr“ ist
if ($owner_type=='usr') {
...
}
Im Anschluss an diese Abfrage müssen nun 2 weitere else if() Abfragen kommen, die auf die neue Owner Typen „group“ und „role“ hin prüfen und eine korrekte Zuweisung vornehmen:
else if ($owner_type=='role') {
$names = array();
$this->get_owner_from_post_data();
foreach ( $owner_ids as $id ) {
echo"id[0]=".$id."
";
$names[] = $id;
}
$displayname = implode( ', ', $names );
}
else if($owner_type == 'group'){
$names = array();
$all_groups = Groups_Group::get_groups();
$this->get_owner_from_post_data();
foreach ( $owner_ids as $id ) {
foreach($all_groups as $group){
if($group->group_id == $id) {
$names[] = $group->name;
}
}
}
asort( $names );
$displayname = implode( ', ', $names );
}
Damit klappt die Zuordnung einwandfrei und in der Spalte „Inhaber“ erscheint nun sowohl der korrekte Owner Type als auch der entsprechende Klarname:
Auch im Frontend wird in der Übersicht für den Ersteller der zugeordnete Inhaber (!= Ersteller) der Datei nun korrekt ausgegeben:
Korrekte Anzeige aller Dateien für Benutzer der Gruppen
Jetzt bleibt noch zu lösen, dass alle Dateien, die für bestimmte Gruppen veröffentlicht wurden, allen Benutzer dieser Gruppe in ihrer persönlichen Übersicht des Kundenbereichs auch angezeigt und zugänglich gemacht werden. Erfahrungsgemäß dürfte es sich wieder um die einfache Abfrage auf owner_type=’usr‘ handeln, die dann durch eine entsprechnde Erweiterung um die Owner Types „Group“ und „role“ zu ergänzen wäre.
Geänderte Klassen
In der Datei .\wp-content\plugins\customer-area\includes\core-addons\customer-private-files\templates\customer-private-files-content.template.php musste aufgrund der geänderten WP_query eine Filterung der anzuzeigenden Posts eingebaut werden.
while ( $content_query->have_posts() ) {
$content_query->the_post();
global $post;
if($this->quick){
if( $po_addon->is_user_authorized_to_see_post($post->ID, $current_user_id) ) include( $item_template );
}
else {include( $item_template ); }
// include( $item_template );
}
In der Klasse .\wp-content\plugins\customer-area\includes\core-classes\widget-content-list.class.php musste die Funktion
function get_content( $args, $instance ) {
// Get user content
$cuar_plugin = CUAR_Plugin::get_instance();
$po_addon = $cuar_plugin->get_addon( 'post-owner' );
$limit = isset( $instance[ 'posts_per_page' ] ) ? $instance[ 'posts_per_page' ] : 5;
$orderby = isset( $instance[ 'orderby' ] ) ? $instance[ 'orderby' ] : 'date';
$order = isset( $instance[ 'order' ] ) ? $instance[ 'order' ] : 'DESC';
$category = isset( $instance[ 'category' ] ) ? $instance[ 'category' ] : -1;
$args = array(
'post_type' => $this->get_post_type(),
'posts_per_page' => $limit,
'orderby' => $orderby,
'order' => $order,
'meta_query' => $po_addon->get_meta_query_post_owned_by( get_current_user_id() )
);
if($po_addon->get_quick_var()) unset($args['meta_query']);
if ( $category>0 ) {
$args[ 'tax_query' ] = array(
array(
'taxonomy' => $this->get_associated_taxonomy(),
'field' => 'id',
'terms' => $category
)
);
}
$args = apply_filters( 'cuar/core/widget/query-args?widget-id=' . $this->id_base, $args );
$posts = get_posts( $args );
$out = array();
if($po_addon->get_quick_var()){
foreach ( $posts as $p ) {
if( !$po_addon->is_user_authorized_to_see_post($p->ID, get_current_user_id()) ) {
continue;
}
$out[] = $p;
}
return $out;
}
return $posts;
}
geändert werden
In der Datei .\wp-content\plugins\customer-area\includes\core-classes\addon-content-page.class.php wurde zunächst mal für test-zwecke eine Variable deklariert, die eine Abwandlung und Verzweigung der WP Query an diversen Stellen im Code ermöglichte
private $quick = true;
Das Hauptproblem war, dass bei Hinzunahme mehrerer Gruppen und der User Role des aktuellen Benutzers in die Meta Query die Bearbeitungszeit der Query mehr als linear zunahm, evtl. gar fast exponentiell!
Spielt sich eine WP_Query mit einer meta_query in der ursprünglichen Form noch im Millisekundenbereich ab, landet man bei ein oder zwei Gruppen und der User Role schnell bei 1-2 Sekunden. Bei einer meta_query in der mit der Relation ‚OR‘ auf den User ID, die User Role und 3 Gruppen abgefragt wird, liegt man schon bei knapp 10-20 Sekunden, bei 4 Gruppen betrug Bearbeitungszeit der Query mit mehreren Minuten so lang, dass dies erstens einem Benutzer nicht zuzumuten wäre, zweitens dies den Server lahmlegt. Dies scheint ein mehr oder weniger bekanntes Problem bei WordPress zu sein, zumindest existiert ein Ticket im Bug Tracking System zu diesem Issue.
Eine elegante Lösung des Kern-Problems war hier auf die schnelle nicht drin, weshalb hier ein Workaround gewählt wurde.
Die function print_page_content musste überarbeitet werden und hinter der if / else if / else Verzweigung wurden folgende Zeile ergänzt:
aus dem Abschnitt
$args = apply_filters( 'cuar/core/page/query-args?slug=' . $page_slug, $args ); $args = apply_filters( 'cuar/core/page/query-args?slug=' . $page_slug . '&display-mode=' . $display_mode, $args ); $content_query = new WP_Query( $args );
wurde
$args = apply_filters( 'cuar/core/page/query-args?slug=' . $page_slug, $args );
$args = apply_filters( 'cuar/core/page/query-args?slug=' . $page_slug . '&display-mode=' . $display_mode, $args );
if($this->quick) unset($args['meta_query']); //löscht meta_query Eintrag, Anzeige wird in template gelöst
if($this->quick) $args['posts_per_page'] = 50;
unset($args['paged']);
$content_query = new WP_Query( $args );
/****************************************************/
$posts = $content_query->get_posts();
$out = array();
if($po_addon->get_quick_var()){
foreach ( $posts as $p ) {
if( !$po_addon->is_user_authorized_to_see_post($p->ID, get_current_user_id()) ) {
continue;
}
$out[] = $p;
}
}
In der function print_dashboard_content in der gleichen Klasse musste ebenfalls wieder der meta_query part gelöscht werden und die Überprüfung der Zurückgegebenen Posts weiter hinten im Programmablauf stattfinden
Nach der Definition der Argumente $args für die WP_Query sind folgende 2 Zeilen einzufügen
if($po_addon->get_quick_var()) unset($args['meta_query']); if($po_addon->get_quick_var()) unset($args['posts_per_page']);
Die erste Zeile wieder um die Rechenzeit für die WP_query gering zu halten, die zweite, weil die Query ohne die in der meta_query angegebenen Parameter deutlich mehr Ergebnisse zurückliefert, die später ausgedünnt werden, wobei die posts_pre_page sich aber auf die zurückgegebene Anzahl der Posts direkt nach der WP_Query bezieht. Erfüllt jetzt keiner dieser Posts die Kriterien (User ID, Gruppe, User Role) um angezeigt zu werden, so erhält man ggf. gar keine zu listenden Posts.
.\wp-content\plugins\customer-area\includes\core-addons\post-owner\post-owner-addon.class.php
Direkt zu Anfang der definierten Class wird eine Variable definiert samt getter Funktion, die die meta_query für WP_Query regelt und den späteren Ablauf der Ergebniss Filterung
public $quick = true;
public function get_quick_var() {return $this->quick;}
Die Funktion function get_owner_types() musste erweitert werden um die owner_types ‚group‘ und ‚role‘
public function get_owner_types() {
if ($this->owner_types==null) {
$this->owner_types = apply_filters('cuar/core/ownership/owner-types', array( 'usr' => __('User', 'cuar'), 'group' => __('Group','cuar'), 'role' => __('Role','cuar') ) );
}
return $this->owner_types;
}
Es wurden ein paar neue Funktionen definiert:
/*
*returns array of groups (ids) for given user_id
*
*/
public function get_user_groups_as_ids($user_id) {
//TO DO: get group membership for $user_id
$users_groups = Groups_user_group::get_groups_for_user_id($user_id);
$group_names = array();
$g_ids = array();
if ($users_groups != false) {
$users_groups_array = (array) $users_groups;
foreach($users_groups_array as $group){
$g_ids[] = $group->group_id;
}
}
return $g_ids;
}
public function get_user_role($user_id){
$user = new WP_User( $user_id );
if ( !empty( $user->roles ) && is_array( $user->roles ) ) {
foreach ( $user->roles as $role )
//return the first user role
return $role;
}
}
/*
*returns array of groups (ids) for given user_id
*
*/
public function get_user_groups_as_names($user_id) {
//TO DO: get group membership for $user_id
$users_groups = Groups_user_group::get_groups_for_user_id($user_id);
$group_names = array();
$g_ids = array();
if ($users_groups != false) {
$users_groups_array = (array) $users_groups;
foreach($users_groups_array as $group){
$g_ids[] = $group->group_id;
$test = Groups_group::read($group->group_id);
$name = $test->name;
if(!empty($name)) {
$group_names[] = $name;
}
}
}
return $group_names;
}
public function filter_posts_by_user_group_role($posts, $user_id){
$out = array();
foreach ( $posts as $p ) {
if( !$this->is_user_authorized_to_see_post($p->ID, $user_id) ) {
continue;
}
$out[] = $p;
}
return $out;
}
/**
* Check if a user is an owner of the given post.
*
* @param int $post_id
* @param int $user_id
*/
public function is_user_authorized_to_see_post( $post_id, $user_id ) {
$result = false;
// We take care of the single user ownership
$owner_type = $this->get_post_owner_type( $post_id );
$owner_ids = $this->get_post_owner_ids( $post_id );
if ( $owner_type=='usr' ) {
$result = in_array( $user_id, $owner_ids );
}
else if ( $owner_type=='group' ) {
$group_ids = $this->get_user_groups_as_ids($user_id);
foreach($group_ids as $group_id){
if($result = in_array($group_id, $owner_ids)) break;
}
}
else if ( $owner_type=='role' ) {
//TO DO: get User Role for $user_id
$user = new WP_User( $user_id );
if ( !empty( $user->roles ) && is_array( $user->roles ) ) {
foreach ( $user->roles as $role ){
// add an array entry for each role for $user_id
$result = in_array( $role, $owner_ids );
if ($result) break;
}
}
}
else {
$result = false;
}
return apply_filters( 'cuar/core/ownership/validate-post-ownership', $result, $post_id, $user_id, $owner_type, $owner_ids );
}
Analog zur function get_printable_owners_for_type_usr() mussten noch zwei Funktionen für die entsprechenden Gruppen und User Role ergänzt werden
/**
* Print a select field with all groups
* @param unknown $field_id
* @param unknown $current_owner_type
* @param unknown $current_owner_id
*/
public function get_printable_owners_for_type_group( $in ) {
$all_groups = Groups_Group::get_groups();
foreach ( $all_groups as $g ) {
$out[ $g->group_id ] = $g->name;
}
return $out;
}
/**
* Print a select field with all roles
* @param unknown $field_id
* @param unknown $current_owner_type
* @param unknown $current_owner_id
*/
public function get_printable_owners_for_type_role( $in ) {
global $wp_roles;
$roles = $wp_roles->get_names();
$all_roles = apply_filters( 'cuar/core/ownership/selectable-owners?owner-type=role', null );
$all_roles = get_editable_roles();
if ( null===$all_roles ) {
$all_roles = get_editable_roles();
}
$all_roles = $wp_roles->get_names();
$out = $in;
foreach ( $all_roles as $r ) {
$out[ $r->ID ] = $r->display_name;
}
return $roles;
}
und diese dann nach der letzten Zeile der Funktion run_addon() registriert werden
add_action('cuar/core/ownership/printable-owners?owner-type=group', array( &$this, 'get_printable_owners_for_type_group'), 10 );
add_action('cuar/core/ownership/printable-owners?owner-type=role', array( &$this, 'get_printable_owners_for_type_role'), 10 );
Weiterhin wurde die Funktion get_meta_query_post_owned_by erweitert um das hinzufügen von Meta Queries zu User Role und User Groups zum meta_query Array
public function get_meta_query_post_owned_by( $user_id ) {
$user_id = apply_filters( 'cuar/core/ownership/content/meta-query/override-owner-id', $user_id );
$base_meta_query = array(
'relation' => 'OR',
$this->get_owner_meta_query_component( 'usr', $user_id )
);
// add user role to meta_query
$base_meta_query[] = $this->get_owner_meta_query_component( 'role', $this->get_user_role($user_id));
// Get ID Array of all groups the user is member of
$g_ids = $this->get_user_groups_as_ids(user_id);
// add groups to meta_query
if(is_array($g_ids)){
foreach($g_ids as $g_id){
$base_meta_query[] = $this->get_owner_meta_query_component( 'group', $g_id);
}
}
return apply_filters( 'cuar/core/ownership/content/meta-query', $base_meta_query, $user_id );
}
.\customer-area\includes\core-classes\widget-content-authors.class.php
In dieser Klasse musste die Funktion get_authors() angepasst werden und zwar der Teil, wo die $args für die Query definiert werden, sowie die anschließende foreach-Schleife
$args = array(
'post_type' => $this->get_post_type(),
'posts_per_page' => -1,
'orderby' => 'date',
'order' => 'DESC',
'meta_query' => $po_addon->get_meta_query_post_owned_by( get_current_user_id() )
);
$args = apply_filters( 'cuar/core/widget/query-args?widget-id=' . $this->id_base, $args );
$posts = get_posts( $args );
$out = array();
foreach ( $posts as $p ) {
$author = get_userdata( $p->post_author );
$out[$p->post_author] = $author->display_name;
}
Daraus wurde
$quick = $po_addon->get_quick_var();
$args = array(
'post_type' => $this->get_post_type(),
'posts_per_page' => -1,
'orderby' => 'date',
'order' => 'DESC',
'meta_query' => $po_addon->get_meta_query_post_owned_by( get_current_user_id() )
);
$args = apply_filters( 'cuar/core/widget/query-args?widget-id=' . $this->id_base, $args );
if($po_addon->get_quick_var()) unset($args['meta_query']); //has to be solved in displaying template
$posts = get_posts( $args );
if($po_addon->get_quick_var()) $posts = $po_addon->filter_posts_by_user_group_role($posts, get_current_user_id());
$out = array();
foreach ( $posts as $p ) {
if($po_addon->get_quick_var()){
if( !$po_addon->is_user_authorized_to_see_post($p->ID, get_current_user_id()) ) {
continue;}
}
$author = get_userdata( $p->post_author );
$out[$p->post_author] = $author->display_name;
}
.\customer-area\includes\core-classes\widget-content-dates.class.php
Ebenso ist in der Klasse widget-content-dates.class.php die Funktion get_dates() anzupassen gewesen.
Diese sieht nun aus wie folgt:
function get_dates() {
global $wpdb;
// TODO SETUP SOME CACHING MECHANISM
// Get user files
$cuar_plugin = CUAR_Plugin::get_instance();
$po_addon = $cuar_plugin->get_addon( 'post-owner' );
$args = array(
'post_type' => $this->get_post_type(),
'posts_per_page' => -1,
'orderby' => 'date',
'order' => 'DESC',
'meta_query' => $po_addon->get_meta_query_post_owned_by( get_current_user_id() )
);
if($po_addon->get_quick_var()) unset($args['meta_query']);
$args = apply_filters( 'cuar/core/widget/query-args?widget-id=' . $this->id_base, $args );
$posts = get_posts( $args );
$out = array();
$current_year = 0;
if ( count( $posts )>0 ) {
foreach ( $posts as $p ) {
if($po_addon->get_quick_var()){
if( !$po_addon->is_user_authorized_to_see_post($p->ID, get_current_user_id()) ) {
continue;}
}
$current_year = mysql2date( 'Y', $p->post_date );
if ( !isset( $out[ $current_year ] ) ) {
$out[ $current_year ] = array();
}
$month_num = mysql2date( 'm', $p->post_date );
$out[ $current_year ][ $month_num ] = $month_num;
}
}
return $out;
}
Änderungen an Plugin Groups
Falls noch nicht weiter oben erwähnt: Auch eine Datei im Plugin Groups muss angepasst werden und zwar .\plugins\groups\lib\core\class-groups-user-group.php
Hier wurde eine static function hinzugefügt, die aus dem modifizierten customer-area plugin aufgerufen wird. Einmal bei einem Upload auf einen Testserver vergessen, schon ging nix mehr 🙂
/**
* Retrieve all groups for a given user_id.
*
* @param int $user_id user's id
* @return object upon success, otherwise false
*/
public static function get_groups_for_user_id( $user_id ) {
global $wpdb;
$result = false;
$user_group_table = _groups_get_tablename( 'user_group' );
$user_group = $wpdb->get_row( $wpdb->prepare(
"SELECT * FROM $user_group_table WHERE user_id = %d",
Groups_Utility::id( $user_id )
) );
$count_groups = $wpdb->query( $wpdb->prepare(
"SELECT * FROM $user_group_table WHERE user_id = %d",
Groups_Utility::id( $user_id )
) );
$user_all_groups = $wpdb->get_results( $wpdb->prepare(
"SELECT * FROM $user_group_table WHERE user_id = %d",
Groups_Utility::id( $user_id )
) );
if ( $user_group !== null ) {
$result = $user_group;
}
if ( $user_all_groups !== null ) {
$result = $user_all_groups;
}
return $result;
}
Komplettes Listing
Alle Angaben ohne Gewähr auf Vollständigkeit oder Korrektheit.
Dieses Tutorial ist als Lösungsansatz für Entwickler gedacht.
Sollte im Tutorial etwas fehlen, unvollständig sein oder nicht funktionieren, finden Sie hier alle geänderten Klassen der Plugins „Customer Area“ und „Groups“ zum Download. Die Plugins wurden wie beschrieben verändert und in Ihrer Funktionalität erweitert. Mit einem Update der Plugins auf eine neuere Version gehen die Änderungen verloren, wenn eine der Klassen durch eine neuere Version überschrieben wird. Die Plugins wurden in mehreren Projekten wie beschrieben eingesetzt und funktionieren einwandfrei mit der geforderten Funktionalität.
Vor dem Upload wurde noch einiges an Debug-Code entfernt und nicht erneut getestet.
Alle geänderten Klassen des Plugins Customer Area (wie oben beschrieben)
Geänderte Klasse des Plugins „Groups“ (wie oben beschrieben)