public function is_member($guid)
{
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('gid', '=', $this->id);
$qb->add_constraint('uid.guid', '=', $guid);
return $qb->count() > 0;
}
public function testCRUD()
{
midcom::get('auth')->request_sudo('midcom.core');
$person = new midcom_db_person();
$stat = $person->create();
$this->assertTrue($stat);
$this->register_object($person);
$person = new midcom_db_person($person->guid);
$this->assertEquals('person #' . $person->id, $person->name);
$this->assertEquals('person #' . $person->id, $person->rname);
$person->firstname = ' Firstname ';
$person->lastname = ' Lastname ';
$stat = $person->update();
$this->assertTrue($stat);
$this->assertEquals('Firstname Lastname', $person->name);
$this->assertEquals('Lastname, Firstname', $person->rname);
$group = $this->create_object('midcom_db_group');
$attributes = array('gid' => $group->id, 'uid' => $person->id);
$member = $this->create_object('midcom_db_member', $attributes);
$stat = $person->delete();
$this->assertTrue($stat);
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('id', '=', $member->id);
$this->assertEquals(0, $qb->count());
midcom::get('auth')->drop_sudo();
}
private function _count_membership_objects($gid, $pid)
{
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('gid', '=', $gid);
$qb->add_constraint('uid', '=', $pid);
return $qb->count();
}
/**
* Loads and prepares the schema database.
*/
public function load_schemadb()
{
$schemadb = midcom_helper_datamanager2_schema::load_database($this->_config->get('schemadb_group'));
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('gid', '=', $this->_group->id);
if ($qb->count_unchecked() > $this->_config->get('list_users_max') && isset($schemadb['default']->fields['persons'])) {
unset($schemadb['default']->fields['persons']);
$field_order_key = array_search('persons', $schemadb['default']->field_order);
if ($field_order_key !== false) {
unset($schemadb['default']->field_order[$field_order_key]);
}
}
unset($qb);
return $schemadb;
}
private function _import_subscribers_organization_member($subscriber, $person, $organization)
{
// Check if person is already in organization
$member = null;
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('uid', '=', $person->id);
$qb->add_constraint('gid', '=', $organization->id);
$members = $qb->execute_unchecked();
if (count($members) > 0) {
// Match found, use it
// Use first match
$member = $members[0];
}
if (!$member) {
// We didn't have person matching the email in DB. Create a new one.
$member = new midcom_db_member();
$member->uid = $person->id;
$member->gid = $organization->id;
if (!$member->create()) {
$this->_request_data['new_objects']['organization_member'] =& $member;
debug_add("Failed to create organization member, reason " . midcom_connection::get_error_string());
return false;
}
}
if (!$this->_datamanager_process('organization_member', $subscriber, $member)) {
return false;
}
return $member;
}
/**
* Deletes all group and event memberships of the original person record. SUDO privileges
* are used at this point, since only memberships are associated to the groups, not persons
* and event memberships belong to the event, again not to the person.
*/
public function _on_deleted()
{
if (!midcom::get('auth')->request_sudo('midcom')) {
debug_add('Failed to get SUDO privileges, skipping membership deletion silently.', MIDCOM_LOG_ERROR);
return;
}
// Delete group memberships
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('uid', '=', $this->id);
$result = $qb->execute();
if ($result) {
foreach ($result as $membership) {
if (!$membership->delete()) {
debug_add("Failed to delete membership record {$membership->id}, last Midgard error was: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
}
}
}
// Delete event memberships
$qb = midcom_db_eventmember::new_query_builder();
$qb->add_constraint('uid', '=', $this->id);
$result = $qb->execute();
if ($result) {
foreach ($result as $membership) {
if (!$membership->delete()) {
debug_add("Failed to delete event membership record {$membership->id}, last Midgard error was: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
}
}
}
midcom::get('auth')->drop_sudo();
}
/**
* @param mixed $handler_id The ID of the handler.
* @param Array $args The argument list.
* @param Array &$data The local request data.
*/
public function _handler_group_memberships($handler_id, array $args, array &$data)
{
// Check if we get the person
$data['person'] = new org_openpsa_contacts_person_dba($args[0]);
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('uid', '=', $data['person']->id);
$data['memberships'] = $qb->execute();
// Group person listing, always work even if there are none
midcom::get()->skip_page_style = true;
}
private function _process_member($member)
{
$adder = array();
$adder['campaign_member'] = $member;
try {
$adder['person'] = org_openpsa_contacts_person_dba::get_cached($member->person);
} catch (midcom_error $e) {
$e->log();
return false;
}
$qb_memberships = midcom_db_member::new_query_builder();
$qb_memberships->add_constraint('uid', '=', $member->person);
$memberships = $qb_memberships->execute_unchecked();
if (!is_array($memberships) || count($memberships) == 0) {
return $adder;
}
switch ($this->membership_mode) {
case 'all':
foreach ($memberships as $k2 => $membership) {
$adder['organization_member'] = $membership;
try {
$adder['organization'] = org_openpsa_contacts_group_dba::get_cached($membership->gid);
} catch (midcom_error $e) {
debug_add("Error fetching org_openpsa_contacts_group_dba #{$membership->gid}, skipping", MIDCOM_LOG_WARN);
return false;
}
return $adder;
}
break;
default:
// Fall-trough intentional
// Fall-trough intentional
case 'first':
// Fall-trough intentional
// Fall-trough intentional
case 'last':
foreach ($memberships as $k2 => $membership) {
$adder['organization_member'] = $membership;
try {
$adder['organization'] = org_openpsa_contacts_group_dba::get_cached($membership->gid);
} catch (midcom_error $e) {
debug_add("Error fetching org_openpsa_contacts_group_dba #{$membership->gid}, skipping", MIDCOM_LOG_WARN);
return false;
}
// Get only first or last membership
if ($this->membership_mode != 'last') {
break;
}
}
return $adder;
break;
}
}
/**
* Support for contacts person merge
*/
function org_openpsa_contacts_duplicates_merge_person(&$person1, &$person2, $mode)
{
switch ($mode) {
case 'all':
break;
case 'future':
// Contacts does not have future references so we have nothing to transfer...
return true;
break;
default:
// Mode not implemented
debug_add("mode {$mode} not implemented", MIDCOM_LOG_ERROR);
return false;
break;
}
$qb = midcom_db_member::new_query_builder();
$qb->begin_group('OR');
// We need the remaining persons memberships later when we compare the two
$qb->add_constraint('uid', '=', $person1->id);
$qb->add_constraint('uid', '=', $person2->id);
$qb->end_group();
$members = $qb->execute();
if ($members === false) {
// Some error with QB
debug_add('QB Error', MIDCOM_LOG_ERROR);
return false;
}
// Transfer memberships
$membership_map = array();
foreach ($members as $member) {
if ($member->uid != $person1->id) {
debug_add("Transferred membership #{$member->id} to person #{$person1->id} (from #{$member->uid})");
$member->uid = $person1->id;
}
if (!isset($membership_map[$member->gid]) || !is_array($membership_map[$member->gid])) {
$membership_map[$member->gid] = array();
}
$membership_map[$member->gid][] = $member;
}
unset($members);
// Merge memberships
foreach ($membership_map as $members) {
foreach ($members as $member) {
if (count($members) == 1) {
// We only have one membership in this group, skip rest of the logic
if (!$member->update()) {
// Failure updating member
debug_add("Failed to update member #{$member->id}, errstr: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
return false;
}
continue;
}
// TODO: Compare memberships to determine which of them are identical and thus not worth keeping
if (!$member->update()) {
// Failure updating member
debug_add("Failed to update member #{$member->id}, errstr: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
return false;
}
}
}
// Transfer metadata dependencies from classes that we drive
$classes = array('midcom_db_member', 'org_openpsa_contacts_person_dba', 'org_openpsa_contacts_group_dba');
$metadata_fields = array('creator' => 'guid', 'revisor' => 'guid');
foreach ($classes as $class) {
$ret = org_openpsa_contacts_duplicates_merge::person_metadata_dependencies_helper($class, $person1, $person2, $metadata_fields);
if (!$ret) {
// Failure updating metadata
debug_add("Failed to update metadata dependencies in class {$class}, errsrtr: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
return false;
}
}
// Copy fields missing from person1 and present in person2 over
$skip_properties = array('id' => true, 'guid' => true);
$changed = false;
foreach ($person2 as $property => $value) {
// Copy only simple properties not marked to be skipped missing from person1
if (empty($person2->{$property}) || !empty($person1->{$property}) || isset($skip_properties[$property]) || is_array($value) || is_object($value)) {
continue;
}
$person1->{$property} = $value;
$changed = true;
}
// Avoid unnecessary updates
if ($changed) {
if (!$person1->update()) {
// Error updating person
debug_add("Error updating person #{$person1->id}, errstr: " . midcom_connection::get_error_string(), MIDCOM_LOG_ERROR);
return false;
}
}
// PONDER: sensible way to do the same for parameters ??
return true;
}
/></td>
<?php
$prefix = midcom_core_context::get()->get_key(MIDCOM_CONTEXT_ANCHORPREFIX);
$linked = 0;
foreach ($data['list_fields'] as $field) {
$value = $data['person']->{$field};
if ($linked < 2 && $data['person']->can_do('midgard:update')) {
if (!$value) {
$value = "<{$field}>";
}
$value = "<a href=\"{$prefix}__mfa/asgard_midcom.admin.user/edit/{$data['person']->guid}/\">{$value}</a>";
$linked++;
}
echo "<td>{$value}</td>\n";
}
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('uid', '=', $data['person']->id);
$memberships = $qb->execute();
$groups = array();
foreach ($memberships as $member) {
// Quick and dirty on-demand group-loading
if ($member->gid != 0 && (!isset($data['groups'][$member->gid]) || !is_object($data['groups'][$member->gid]))) {
$data['groups'][$member->gid] = new midcom_db_group((int) $member->gid);
}
if (!isset($data['groups'][$member->gid]) || !is_object($data['groups'][$member->gid])) {
if ($member->gid == 0) {
$groups[] = 'Midgard Administrators';
} else {
$groups[] = "#{$member->gid}";
}
continue;
/**
* Find out how a person prefers to get the event notification
*
* @param string $action Key of the event in format component:event
* @param string $recipient GUID of the receiving person
* @return Array options supported by user
*/
private static function _merge_notification_prefences($component, $action, $recipient)
{
// TODO: Should we sudo here to ensure getting correct prefs regardless of ACLs?
$preference = 'none';
try {
$recipient = new midcom_db_person($recipient);
} catch (midcom_error $e) {
return $preference;
}
// If user has preference for this message, we use that
$personal_preferences = $recipient->list_parameters('org.openpsa.notifications');
if (count($personal_preferences) > 0 && array_key_exists("{$component}:{$action}", $personal_preferences)) {
$preference = $personal_preferences[$action];
return $preference;
}
// Fall back to component defaults
$customdata = midcom::get('componentloader')->get_all_manifest_customdata('org.openpsa.notifications');
if (!empty($customdata[$component][$action]['default'])) {
$preference = $customdata[$component][$action]['default'];
}
// Seek possible preferences for this action from user's groups
$qb = new midgard_query_builder('midgard_parameter');
$qb->add_constraint('domain', '=', 'org.openpsa.notifications');
$qb->add_constraint('name', '=', "{$component}:{$action}");
// Seek user's groups
$member_qb = midcom_db_member::new_query_builder();
$member_qb->add_constraint('uid', '=', (int) $recipient->id);
$memberships = $member_qb->execute();
$qb->begin_group('OR');
foreach ($memberships as $member) {
$group = new midcom_db_group($member->gid);
$qb->add_constraint('parentguid', '=', $group->guid);
}
$qb->end_group();
$group_preferences = $qb->execute();
if (count($group_preferences) > 0) {
foreach ($group_preferences as $preference) {
$preference = $preference->value;
}
}
return $preference;
}
/**
* Checks whether the given user is a member of this group.
*
* @param midcom_db_person The person to check.
* @return boolean Indicating membership.
*/
function is_member($person)
{
$qb = midcom_db_member::new_query_builder();
$qb->add_constraint('gid', '=', $this->id);
$qb->add_constraint('uid', '=', $person->id);
$result = $qb->count();
if ($result == 0) {
return false;
}
return true;
}
