public function get_read(array $args)
{
parent::get_read($args);
$this->data['groups'] = array();
$this->data['is_challenger'] = $this->is_challenger();
if ($this->data['is_challenger']) {
$this->data['groups_url'] = midgardmvc_core::get_instance()->dispatcher->generate_url('index', array(), 'fi_openkeidas_groups');
$this->data['update_url'] = $this->get_url_update();
$this->data['delete_url'] = midgardmvc_core::get_instance()->dispatcher->generate_url('challenge_delete', array('challenge' => $this->object->guid), $this->request);
}
$activityobject = null;
if ($this->object->activity) {
$activityobject = fi_openkeidas_diary_activities::get($this->object->activity);
}
$this->object->activityobject = $activityobject;
$this->data['challenger'] = new fi_openkeidas_groups_group($this->object->challenger);
$mc = new midgard_collector('fi_openkeidas_diary_challenge_participant', 'challenge', $this->object->id);
//$mc->add_constraint('metadata.isapproved', '=', true);
$mc->set_key_property('grp');
$mc->execute();
$grp_ids = array_keys($mc->list_keys());
if (count($grp_ids) == 0) {
return;
}
$qb = new midgard_query_builder('fi_openkeidas_groups_group');
$qb->add_constraint('id', 'IN', $grp_ids);
$qb->add_order('metadata.score', 'DESC');
$this->data['groups'] = array_map(function ($group) use($activityobject) {
$group->url = midgardmvc_core::get_instance()->dispatcher->generate_url('group_read', array('group' => $group->guid), 'fi_openkeidas_groups');
$group->activity = fi_openkeidas_diary_logs::group_duration_this_week($group, $activityobject);
return $group;
}, $qb->execute());
}
public function get_read(array $args)
{
parent::get_read($args);
$this->data['admins'] = array();
$this->data['is_admin'] = false;
$qb = new midgard_query_builder('fi_openkeidas_groups_group_member');
$qb->add_constraint('grp', '=', $this->object->id);
$qb->add_constraint('admin', '=', true);
$qb->add_constraint('metadata.isapproved', '=', true);
$admins = $qb->execute();
foreach ($admins as $admin) {
$this->data['admins'][] = new midgard_person($admin->person);
if ($admin->person == midgardmvc_core::get_instance()->authentication->get_person()->id) {
$this->data['is_admin'] = true;
}
}
if ($this->data['is_admin']) {
$this->data['members'] = array();
$qb = new midgard_query_builder('fi_openkeidas_groups_group_member');
$qb->add_constraint('grp', '=', $this->object->id);
$qb->add_constraint('admin', '=', false);
$members = $qb->execute();
foreach ($members as $member) {
$this->data['members'][] = new midgard_person($member->person);
}
$this->data['approve_url'] = midgardmvc_core::get_instance()->dispatcher->generate_url('group_join_approve', array('group' => $this->object->guid), $this->request);
}
$this->data['is_member'] = $this->is_member();
$this->data['join_url'] = midgardmvc_core::get_instance()->dispatcher->generate_url('group_join', array('group' => $this->object->guid), $this->request);
if (!$this->object->autocreated) {
$this->data['leave_url'] = midgardmvc_core::get_instance()->dispatcher->generate_url('group_leave', array('group' => $this->object->guid), $this->request);
}
$this->data['challenges'] = array();
$mc = new midgard_collector('fi_openkeidas_groups_group_member', 'person', midgardmvc_core::get_instance()->authentication->get_person()->id);
$mc->add_constraint('metadata.isapproved', '=', true);
$mc->set_key_property('grp');
$mc->execute();
$grp_ids = array_keys($mc->list_keys());
if (count($grp_ids) == 0) {
return;
}
$qb = new midgard_query_builder('fi_openkeidas_diary_challenge');
$qb->add_constraint('challenger', 'IN', $grp_ids);
$qb->add_constraint('challenger', '<>', $this->object->id);
$qb->add_constraint('enddate', '>', new DateTime());
$challenges = $qb->execute();
foreach ($challenges as $challenge) {
$qb = new midgard_query_builder('fi_openkeidas_diary_challenge_participant');
$qb->add_constraint('challenge', '=', $challenge->id);
$qb->add_constraint('grp', '=', $this->object->id);
if ($qb->count() > 0) {
continue;
}
$challenge->url = midgardmvc_core::get_instance()->dispatcher->generate_url('challenge_challenge', array('challenge' => $challenge->guid, 'group' => $this->object->guid), 'fi_openkeidas_diary');
$this->data['challenges'][] = $challenge;
}
}
public static function group_duration_within(DateTime $from, DateTime $to, fi_openkeidas_groups_group $group, fi_openkeidas_diary_activity $activity = null)
{
midgardmvc_core::get_instance()->authorization->require_user();
$mc = new midgard_collector('fi_openkeidas_groups_group_member', 'grp', $group->id);
$mc->add_constraint('metadata.isapproved', '=', true);
$mc->set_key_property('person');
$mc->execute();
return self::average_duration_within($from, $to, array_keys($mc->list_keys()), $activity);
}
/**
* Returns the Parent of the Attachment, which is identified by the table/id combination
* in the attachment record. The table in question is used to identify the object to
* use. If multiple objects are registered for a given table, the first matching class
* returned by the dbfactory is used (which is usually rather arbitrary).
*
* @return MidgardObject Parent object.
*/
public static function get_parent_guid_uncached_static($guid, $classname = __CLASS_)
{
$mc = new midgard_collector('midgard_attachment', 'guid', $guid);
$mc->set_key_property('parentguid');
$mc->execute();
$link_values = $mc->list_keys();
if (empty($link_values)) {
return null;
}
return key($link_values);
}
/**
* Returns the object GUID the location is stored for
*
* @return string Parent GUID or null if there is none
*/
public static function get_parent_guid_uncached_static($guid, $classname = __CLASS_)
{
$mc = new midgard_collector('org_routamc_positioning_location', 'guid', $guid);
$mc->set_key_property('parent');
$mc->execute();
$link_values = $mc->list_keys();
if (!$link_values) {
return null;
}
foreach ($link_values as $key => $value) {
return $key;
}
}
public static function add_challenges_for_group(fi_openkeidas_groups_group $group)
{
$mc = new midgard_collector('fi_openkeidas_diary_challenge_participant', 'grp', $group->id);
//$mc->add_constraint('metadata.isapproved', '=', true);
$mc->add_constraint('challenge.start', '<=', new DateTime());
$mc->add_constraint('challenge.enddate', '>', new DateTime());
$mc->set_key_property('challenge');
$mc->execute();
$challenge_ids = array_keys($mc->list_keys());
if (count($challenge_ids) == 0) {
return $group;
}
$qb = new midgard_query_builder('fi_openkeidas_diary_challenge');
$qb->add_constraint('id', 'IN', $challenge_ids);
$group->challenges = array();
$challenges = $qb->execute();
foreach ($challenges as $challenge) {
$challenge->url = midgardmvc_core::get_instance()->dispatcher->generate_url('challenge_read', array('challenge' => $challenge->guid), 'fi_openkeidas_diary');
$group->challenges[] = $challenge;
}
return $group;
}
/**
* Helper function that sets the request data for hour reports
*
* @param &$array The array returned by collector
*/
private function _add_hour_data(&$array)
{
static $customer_cache = array();
if (!isset($customer_cache[$array['task']])) {
$customer = 0;
$customer_label = $this->_l10n->get('no customer');
if ($array['task'] != 0) {
$mc = new midgard_collector('org_openpsa_task', 'id', $array['task']);
$mc->set_key_property('id');
$mc->add_value_property('customer');
$mc->execute();
$customer_id = $mc->get_subkey($array['task'], 'customer');
if ($customer_id) {
try {
$customer = new org_openpsa_contacts_group_dba($customer_id);
$customer_label = $customer->official;
$customer = $customer_id;
} catch (midcom_error $e) {
}
}
}
$customer_cache[$array['task']] = $customer;
if (!isset($this->_request_data['customers'][$customer])) {
$this->_request_data['customers'][$customer] = $customer_label;
}
}
$customer = $customer_cache[$array['task']];
$category = 'uninvoiceable';
if ($array['invoiceable']) {
$category = 'invoiceable';
}
if (!isset($this->_request_data['hours'][$category][$customer])) {
$this->_request_data['hours'][$category][$customer] = $array['hours'];
} else {
$this->_request_data['hours'][$category][$customer] += $array['hours'];
}
$this->_request_data['hours']['total_' . $category] += $array['hours'];
}
/**
* This is an internal helper function, which may only be called statically.
*
* It is used by get_all_privileges in case that there is no cache hit. It will query the
* database and construct all necessary objects out of it.
*
* @param string $guid The GUID of the object for which to query ACL data.
* @param string $type SELF or CONTENT
* @return Array A list of midcom_core_privilege instances.
*/
protected static function _query_privileges($guid, $type)
{
$result = array();
$mc = new midgard_collector('midcom_core_privilege_db', 'objectguid', $guid);
$mc->add_constraint('value', '<>', MIDCOM_PRIVILEGE_INHERIT);
if ($type == 'CONTENT') {
$mc->add_constraint('assignee', '<>', 'SELF');
} else {
$mc->add_constraint('assignee', '=', 'SELF');
}
$mc->set_key_property('guid');
$mc->add_value_property('id');
$mc->add_value_property('privilegename');
$mc->add_value_property('assignee');
$mc->add_value_property('classname');
$mc->add_value_property('value');
midcom_connection::set_error(MGD_ERR_OK);
$mc->execute();
$privileges = $mc->list_keys();
if (!$privileges) {
if (midcom_connection::get_error() != MGD_ERR_OK) {
debug_add("Failed to retrieve all {$type} privileges for the Object GUID {$guid}: " . midcom_connection::get_error_string(), MIDCOM_LOG_INFO);
debug_print_r('Result was:', $result);
if (isset($php_errormsg)) {
debug_add("Error message was: {$php_errormsg}", MIDCOM_LOG_ERROR);
}
throw new midcom_error('Privilege collector failed to execute: ' . midcom_connection::get_error_string());
}
return $result;
}
foreach ($privileges as $privilege_guid => $value) {
$privilege = $mc->get($privilege_guid);
$privilege['objectguid'] = $guid;
$privilege['guid'] = $privilege_guid;
$privilege_object = new midcom_core_privilege($privilege);
if (!isset($privilege_object->assignee)) {
// Invalid privilege, skip
continue;
}
$privilege_object->scope = $privilege_object->_get_scope();
$return[] = $privilege_object;
}
return $return;
}
/**
* Adds a passed rule for the passed class to the querybuilder
*
* @param array $rule contains the rule
* @param string $class name of the class the rule will be added to
* @param string $person_property contains the name of the property of the
* passed class which links to the person
*/
function add_misc_rule(array $rule, $class, $person_property)
{
$persons = array(0 => -1);
$match = $rule['match'];
$constraint_match = "IN";
if ($rule['match'] == '<>' || $rule['match'] == 'NOT LIKE') {
$constraint_match = "NOT IN";
switch ($rule['match']) {
case '<>':
$match = '=';
break;
case 'NOT LIKE':
$match = 'LIKE';
break;
default:
$match = '=';
break;
}
}
$mc_misc = new midgard_collector($class, 'metadata.deleted', false);
$mc_misc->set_key_property('id');
$mc_misc->add_constraint($rule['property'], $match, $rule['value']);
$mc_misc->add_value_property($person_property);
$mc_misc->execute();
$keys = $mc_misc->list_keys();
foreach ($keys as $key => $value) {
// get user-id
$persons[] = $mc_misc->get_subkey($key, $person_property);
}
$this->_result_mc->add_constraint('id', $constraint_match, $persons);
}
/**
* Generate a valid cache identifier for a context of the current request
*/
function generate_request_identifier($context, $customdata = null)
{
$module_name = $GLOBALS['midcom_config']['cache_module_content_name'];
if ($module_name == 'auto') {
$module_name = midcom_connection::get_unique_host_name();
}
$identifier_source = 'CACHE:' . $module_name;
// Cache the request identifier so that it doesn't change between start and end of request
static $identifier_cache = array();
if (isset($identifier_cache[$context])) {
// FIXME: Use customdata here too
return $identifier_cache[$context];
}
if (!isset($customdata['cache_module_content_caching_strategy'])) {
$cache_strategy = $GLOBALS['midcom_config']['cache_module_content_caching_strategy'];
} else {
$cache_strategy = $customdata['cache_module_content_caching_strategy'];
}
switch ($cache_strategy) {
case 'memberships':
if (!midcom_connection::get_user()) {
$identifier_source .= ';USER=ANONYMOUS';
break;
}
$mc = new midgard_collector('midgard_member', 'uid', midcom_connection::get_user());
$mc->set_key_property('gid');
$mc->execute();
$gids = $mc->list_keys();
unset($mc);
$identifier_source .= ';GROUPS=' . implode(',', array_keys($gids));
unset($gids);
break;
case 'public':
$identifier_source .= ';USER=EVERYONE';
break;
case 'user':
default:
$identifier_source .= ';USER='******';URL=' . midcom_core_context::get()->get_key(MIDCOM_CONTEXT_URI);
} else {
$identifier_source .= ';URL=' . $_SERVER['REQUEST_URI'];
}
// check_dl_hit needs to take config changes into account...
if (!is_null($customdata)) {
$identifier_source .= ';' . serialize($customdata);
}
// TODO: Add browser capability data (mobile, desktop browser etc) from WURFL here
debug_add("Generating context {$context} request-identifier from: {$identifier_source}");
debug_print_r('$customdata was: ', $customdata);
$identifier_cache[$context] = 'R-' . md5($identifier_source);
return $identifier_cache[$context];
}
/**
* Modify a query instance for searching by username, with differences between
* mgd1 and mgd2 abstracted away
*
* @param midcom_core_query &$query The QB or MC instance to work on
* @param string $operator The operator for the username constraint
* @param string $value The value for the username constraint
*/
public static function add_username_constraint(midcom_core_query &$query, $operator, $value)
{
if (method_exists('midgard_user', 'login')) {
$mc = new midgard_collector('midgard_user', 'authtype', $GLOBALS['midcom_config']['auth_type']);
$mc->set_key_property('person');
$mc->add_constraint('login', $operator, $value);
$mc->execute();
$user_results = $mc->list_keys();
if (count($user_results) < 1) {
// make sure we don't return any results if no midgard_user entry was found
$query->add_constraint('id', '=', 0);
} else {
$query->add_constraint('guid', 'IN', array_keys($user_results));
}
} else {
$query->add_constraint('username', $operator, $value);
}
}
/**
* Retrieves a given metadata key, postprocesses it where necessary
* and stores it into the local cache.
*
* - Person references (both guid and id) get resolved into the corresponding
* Person object.
* - created, creator, edited and editor are taken from the corresponding
* MidgardObject fields.
* - Parameters are accessed using their midgard-created member variables
* instead of accessing the database using $object->parameter directly for
* performance reasons (this will implicitly use the NAP cache for these
* values as well. (Implementation note: Variable variables have to be
* used for this, as we have dots in the member name.)
*
* Note, that we hide any errors from not existent properties explicitly,
* as a few of the MidCOM objects do not support all of the predefined meta
* data fields, PHP will default to "0" in these cases. For Person IDs, this
* "0" is rewritten to "1" to use the MidgardAdministrator account instead.
*
* @param string $key The key to retrieve.
*/
private function _retrieve_value($key)
{
switch ($key) {
// Time-based properties
case 'created':
case 'revised':
case 'published':
case 'locked':
case 'approved':
case 'schedulestart':
case 'scheduleend':
case 'exported':
case 'imported':
if (extension_loaded('midgard2') && isset($this->__metadata->{$key})) {
//This is ugly, but seems the only possible way...
if ((string) $this->__metadata->{$key} === "0001-01-01T00:00:00+00:00") {
$value = 0;
} else {
$value = (int) $this->__metadata->{$key}->format('U');
}
} else {
if (empty($this->__metadata->{$key}) || $this->__metadata->{$key} == '0000-00-00 00:00:00') {
$value = 0;
} else {
$value = strtotime("{$this->__metadata->{$key}} UTC");
}
}
break;
// Person properties
// Person properties
case 'creator':
case 'revisor':
case 'locker':
case 'approver':
$value = $this->__metadata->{$key};
if (!$value) {
// Fall back to "Midgard root user" if person is not found
static $root_user_guid = null;
if (!$root_user_guid) {
$mc = new midgard_collector('midgard_person', 'id', 1);
$mc->set_key_property('guid');
$mc->execute();
$guids = $mc->list_keys();
if (empty($guids)) {
$root_user_guid = 'f6b665f1984503790ed91f39b11b5392';
} else {
foreach ($guids as $guid => $val) {
$root_user_guid = $guid;
}
}
}
$value = $root_user_guid;
}
break;
// Other midgard_metadata properties
// Other midgard_metadata properties
case 'revision':
case 'hidden':
case 'navnoentry':
case 'size':
case 'deleted':
case 'score':
case 'authors':
case 'owner':
$value = $this->__metadata->{$key};
break;
// Fall-back for non-core properties
// Fall-back for non-core properties
default:
$dm = $this->get_datamanager();
if (!isset($dm->types[$key])) {
// Fall back to the parameter reader for non-core MidCOM metadata params
$value = $this->__object->get_parameter('midcom.helper.metadata', $key);
} else {
$value = $dm->types[$key]->convert_to_csv();
}
break;
}
$this->_cache[$key] = $value;
}
/**
* Helper function to create & recalculate existing invoice_items by tasks
*
* @param array $tasks array containing the task id's to recalculate for - if empty all tasks will be recalculated
*/
public function _recalculate_invoice_items($tasks = array(), $skip_invoice_update = false)
{
$result_items = array();
$result_tasks = array();
//get hour_reports for this invoice - mc ?
$qb_hour_reports = org_openpsa_projects_hour_report_dba::new_query_builder();
$qb_hour_reports->add_constraint('invoice', '=', $this->id);
if (!empty($tasks)) {
$qb_hour_reports->add_constraint('task', 'IN', $tasks);
//if there is a task passed it must be calculated even
//if it doesn't have associated hour_reports
foreach ($tasks as $task_id) {
$result_tasks[$task_id] = 0;
}
}
$hour_reports = $qb_hour_reports->execute();
// sums up the hours of hour_reports for each task
foreach ($hour_reports as $hour_report) {
if (!array_key_exists($hour_report->task, $result_tasks)) {
$result_tasks[$hour_report->task] = 0;
}
//only add invoiceable hour_reports
if ($hour_report->invoiceable) {
$result_tasks[$hour_report->task] += $hour_report->hours;
}
}
foreach ($result_tasks as $task_id => $hours) {
$invoice_item = $this->_probe_invoice_item_for_task($task_id);
//get deliverable for this task
$mc_task_agreement = new midgard_collector('org_openpsa_task', 'id', $task_id);
$mc_task_agreement->set_key_property('id');
$mc_task_agreement->add_value_property('title');
$mc_task_agreement->add_value_property('agreement');
$mc_task_agreement->add_constraint('agreement', '<>', 0);
$mc_task_agreement->execute();
$mc_task_key = $mc_task_agreement->list_keys();
$deliverable = null;
foreach ($mc_task_key as $key => $empty) {
try {
$deliverable = new org_openpsa_sales_salesproject_deliverable_dba((int) $mc_task_agreement->get_subkey($key, 'agreement'));
$invoice_item->pricePerUnit = $deliverable->pricePerUnit;
$invoice_item->deliverable = $deliverable->id;
//calculate price
if ($deliverable->invoiceByActualUnits || $deliverable->plannedUnits == 0) {
$invoice_item->units = $hours;
} else {
$invoice_item->units = $deliverable->plannedUnits;
}
} catch (midcom_error $e) {
$e->log();
$invoice_item->units = $hours;
}
}
if ($invoice_item->description == '') {
$invoice_item->description = $mc_task_agreement->get_subkey($task_id, 'title');
}
$invoice_item->skip_invoice_update = $skip_invoice_update;
$invoice_item->update();
$result_items[] = $invoice_item;
}
return $result_items;
}
/**
* Get the GUID of the object's parent. This is done by reading up or parent
* property values, which will give us the parent's ID. Since the ID => GUID relation
* won't change, the corresponding GUID is then stored in an in-request static cache
*/
public static function get_parent_guid_uncached_static($object_guid, $class_name)
{
static $parent_mapping = array();
$class_name = midcom::get('dbclassloader')->get_mgdschema_class_name_for_midcom_class($class_name);
$reflector = new midgard_reflection_property($class_name);
$up_property = midgard_object_class::get_property_up($class_name);
if (!empty($up_property)) {
$target_property = $reflector->get_link_target($up_property);
// Up takes precedence over parent
$mc = new midgard_collector($class_name, 'guid', $object_guid);
$mc->set_key_property($up_property);
$mc->execute();
$link_values = $mc->list_keys();
if (!empty($link_values)) {
list($link_value, $dummy) = each($link_values);
unset($mc, $link_values, $dummy);
if (!empty($link_value)) {
if (!array_key_exists($class_name, $parent_mapping)) {
$parent_mapping[$class_name] = array();
}
if (array_key_exists($link_value, $parent_mapping[$class_name])) {
return $parent_mapping[$class_name][$link_value];
}
$mc2 = new midgard_collector($class_name, $target_property, $link_value);
$mc2->set_key_property('guid');
$mc2->execute();
$guids = $mc2->list_keys();
if (!is_array($guids)) {
unset($mc2, $guids, $link_value);
$parent_mapping[$class_name][$link_value] = null;
return $parent_mapping[$class_name][$link_value];
}
list($parent_guid, $dummy) = each($guids);
$parent_mapping[$class_name][$link_value] = $parent_guid;
unset($mc2, $guids, $link_value, $dummy);
return $parent_guid;
}
} else {
unset($mc, $link_values);
}
}
$parent_property = midgard_object_class::get_property_parent($class_name);
if (!empty($parent_property) && $reflector->get_link_target($parent_property)) {
$target_property = $reflector->get_link_target($parent_property);
$target_class = $reflector->get_link_name($parent_property);
$mc = new midgard_collector($class_name, 'guid', $object_guid);
$mc->set_key_property($parent_property);
$mc->execute();
$link_values = $mc->list_keys();
if (!empty($link_values)) {
list($link_value, $dummy) = each($link_values);
unset($mc, $link_values, $dummy);
if (!empty($link_value)) {
if (!array_key_exists($target_class, $parent_mapping)) {
$parent_mapping[$target_class] = array();
}
if (array_key_exists($link_value, $parent_mapping[$target_class])) {
return $parent_mapping[$target_class][$link_value];
}
$mc2 = new midgard_collector($target_class, $target_property, $link_value);
$mc2->set_key_property('guid');
$mc2->execute();
$guids = $mc2->list_keys();
if (!is_array($guids)) {
unset($mc2, $guids, $link_value);
$parent_mapping[$target_class][$link_value] = null;
return $parent_mapping[$target_class][$link_value];
}
list($parent_guid, $dummy) = each($guids);
$parent_mapping[$target_class][$link_value] = $parent_guid;
unset($mc2, $guids, $link_value, $dummy);
return $parent_guid;
}
} else {
unset($mc, $link_values);
}
}
// FIXME: Handle GUID linking
return null;
}
/**
* This method returns a list of all groups in which the
* MidCOM user passed is a member.
*
* This function is always called statically.
*
* @param midcom_core_user $user The user that should be looked-up.
* @return Array An array of member groups or false on failure, indexed by their ID.
*/
public static function list_memberships($user)
{
$mc = new midgard_collector('midgard_member', 'uid.guid', $user->guid);
$mc->add_constraint('gid', '<>', 0);
$mc->set_key_property('gid');
@$mc->execute();
$result = $mc->list_keys();
if (empty($result)) {
return $result;
}
$return = array();
foreach ($result as $gid => $empty) {
try {
$group = new midcom_core_group($gid);
} catch (Exception $e) {
debug_add("The group {$gid} is unknown, skipping the membership record.", MIDCOM_LOG_ERROR);
debug_add('Last Midgard error was: ' . midcom_connection::get_error_string());
continue;
}
$return[$group->id] = $group;
}
return $return;
}
/**
* This is a wrapper for get_user, which allows user retrieval by its email address.
* If the email is empty or unknown, false is returned.
*
* @param string $email The email of the user to look up.
* @return array|midcom_core_user A reference to the user object matching the email, array if multiple matches
* or false if the email is unknown.
*/
function get_user_by_email($email)
{
static $persons_by_email = array();
if (empty($email)) {
return false;
}
if (array_key_exists($email, $persons_by_email)) {
return $persons_by_email[$email];
}
// Seek user based on the primary email field
$qb = new midgard_query_builder($GLOBALS['midcom_config']['person_class']);
$qb->add_constraint('email', '=', $email);
// FIXME: Some sites like maemo.org instead of deleting users just remove their account and prefix firstname by "DELETE "
$qb->add_constraint('firstname', 'NOT LIKE', 'DELETE %');
$results = @$qb->execute();
if (!$results || count($results) == 0) {
// Try finding user based on the other email fields
$person_guids = array();
$mc = new midgard_collector('midgard_parameter', 'value', $email);
$mc->set_key_property('parentguid');
$mc->add_constraint('domain', '=', 'org.imc.vcard:email');
$mc->execute();
$guids = $mc->list_keys();
foreach ($guids as $guid => $array) {
$person_guids[] = $guid;
}
if (empty($person_guids)) {
return false;
}
$qb = new midgard_query_builder($GLOBALS['midcom_config']['person_class']);
$qb->add_constraint('guid', 'IN', $person_guids);
// FIXME: Some sites like maemo.org instead of deleting users just remove their account and prefix firstname by "DELETE "
$qb->add_constraint('firstname', 'NOT LIKE', 'DELETE %');
$results = @$qb->execute();
if (empty($results)) {
$persons_by_email[$email] = false;
return false;
}
}
if (count($results) > 1) {
$persons_by_email[$email] = array();
foreach ($results as $result) {
$persons_by_email[$email][] = $this->get_user($result);
}
return $persons_by_email[$email];
}
$persons_by_email[$email] = $this->get_user($results[0]);
return $persons_by_email[$email];
}
/**
* Search products using Midgard 1.8+ Query Builder
*/
private function _qb_search($constraints)
{
$qb = new org_openpsa_qbpager('org_openpsa_products_product_dba', 'org_openpsa_products_product_dba');
$qb->results_per_page = $this->_config->get('products_per_page');
// Check that the object has correct schema
$mc = new midgard_collector('midgard_parameter', 'domain', 'midcom.helper.datamanager2');
$mc->set_key_property('parentguid');
$mc->add_constraint('name', '=', 'schema_name');
$mc->add_constraint('value', '=', $this->_request_data['search_schema']);
$mc->execute();
$keys = $mc->list_keys();
if (!empty($keys)) {
$qb->add_constraint('guid', 'IN', array_keys($keys));
}
unset($mc, $keys);
if ($this->_request_data['search_type'] == 'OR') {
$qb->begin_group('OR');
}
foreach ($constraints as $constraint) {
$storage = $this->_request_data['schemadb_product'][$this->_request_data['search_schema']]->fields[$constraint['property']]['storage'];
debug_print_r('constraint', $constraint);
debug_print_r('storage', $storage);
if (!is_array($storage) || preg_match('/^%+$/', $constraint['value'])) {
continue;
}
if ($storage['location'] == 'parameter' || $storage['location'] == 'configuration') {
$mc = new midgard_collector('midgard_parameter', 'domain', $storage['domain']);
$mc->set_key_property('parentguid');
$mc->add_constraint('name', '=', $constraint['property']);
$mc->add_constraint('value', $constraint['constraint'], $constraint['value']);
$mc->execute();
$keys = $mc->list_keys();
if (!empty($keys)) {
$qb->add_constraint('guid', 'IN', array_keys($keys));
}
unset($mc, $keys);
} else {
// Simple field storage
if (is_numeric($constraint['value'])) {
// TODO: When 1.8.4 becomes more common we can reflect this instead
$constraint['value'] = (int) $constraint['value'];
}
$qb->add_constraint($storage['location'], $constraint['constraint'], $constraint['value']);
}
}
if ($this->_request_data['search_type'] == 'OR') {
$qb->end_group();
}
foreach ($this->_config->get('search_index_order') as $ordering) {
$this->_add_ordering($qb, $ordering);
}
$ret = $qb->execute();
/* FIXME: It this the right way to do this? */
$this->_request_data['search_qb'] =& $qb;
// Check schemas this way until the core issue is fixed
foreach ($ret as $k => $product) {
$schema = $product->get_parameter('midcom.helper.datamanager2', 'schema_name');
debug_add("product schema '{$schema}' vs desired schema '{$this->_request_data['search_schema']}'");
if ($schema == $this->_request_data['search_schema']) {
continue;
}
unset($ret[$k]);
}
// array_merge reindexes the array to be continous
return array_merge($ret);
}
/**
* Small helper to get the GUID of the user's first group. This is used mainly to populate
* the owner field during DBa object create calls
*
* @return mixed GUID of the first group found or false
*/
function get_first_group_guid()
{
if (!is_null($this->_direct_groups)) {
if (empty($this->_direct_groups)) {
// User is not member of any groups
return false;
}
return $this->_direct_groups[key($this->_direct_groups)]->get_storage()->guid;
}
//Not yet initialized, try to load one midgard group
$mc = new midgard_collector('midgard_member', 'uid', $this->_storage->id);
$mc->add_constraint('gid', '<>', 0);
$mc->set_key_property('gid');
$mc->set_limit(1);
@$mc->execute();
$result = $mc->list_keys();
if (!empty($result)) {
if ($group = midcom::get('auth')->get_group(key($result))) {
return $group->get_storage()->guid;
}
}
$this->_load_all_groups();
if (!empty($this->_direct_groups)) {
return $this->_direct_groups[key($this->_direct_groups)]->get_storage()->guid;
}
return false;
}