protected function setUp()
{
if (MIDCOM_TESTS_ENABLE_OUTPUT) {
echo "\nsetUp\n\n";
}
if (!extension_loaded('midgard') && !extension_loaded('midgard2')) {
$this->markTestSkipped('Midgard extension is not available');
}
if (!isset($_MIDGARD)) {
// Start up a Midgard connection
$cnc = new midgard_connection();
$cnc->open(MIDGARD_CONFIG);
$cnc->set_debuglevel(MIDCOM_TESTS_LOGLEVEL);
if (is_int(MIDCOM_TESTS_SITEGROUP)) {
$sg = mgd_get_sitegroup(MIDCOM_TESTS_SITEGROUP);
$cnc->set_sitegroup($sg->name);
} else {
$cnc->set_sitegroup(MIDCOM_TESTS_SITEGROUP);
}
}
if (!isset($_MIDCOM)) {
// Load MidCOM with the manual dispatcher
$_MIDCOM = new midcom_core_midcom('manual');
}
}
public function __construct(array $configuration)
{
$this->configuration = $configuration;
if (!isset($configuration['directory'])) {
throw new Exception("Cache directory not configured");
}
$_config = midgard_connection::get_instance()->config;
if (isset($_ENV['MIDGARD_ENV_GLOBAL_CACHEDIR'])) {
// Fluid instance has a dynamic cache directory location
// FIXME: We need to make configuration more dynamic to support this properly
$this->cache_directory = $_ENV['MIDGARD_ENV_GLOBAL_CACHEDIR'];
} elseif ($_config->cachedir != '') {
$this->cache_directory = $_config->cachedir;
} else {
$this->cache_directory = str_replace('__MIDGARDCACHE__', $this->get_cache_directory(), $configuration['directory']);
}
if (!file_exists($this->cache_directory)) {
$res = mkdir($this->cache_directory, 0777, true);
if (false === $res) {
throw new RuntimeException("Couldn't create '{$this->cache_directory}' cache directory");
}
}
if (!is_writable($this->cache_directory)) {
throw new Exception("Cache directory {$this->cache_directory} is not writable");
}
}
private function append_nodes(\DomNode $node, $parent)
{
if ($node->localName != 'node') {
return;
}
$name = "";
foreach ($node->attributes as $element) {
/* The name of each JCR node or property becomes the value of the sv:name */
if ($element->name != 'name') {
continue;
}
$name = $element->value;
}
/* The hierarchy of the content repository nodes and properties is reflected in
* the hierarchy of the corresponding XML elements. */
$mvc_node = new midgardmvc_core_node();
$mvc_node->name = $name;
$mvc_node->up = $parent->id;
$mvc_node->create();
/* If there's duplicate, get it and reuse */
if (midgard_connection::get_instance()->get_error() == MGD_ERR_DUPLICATE) {
$q = new \midgard_query_select(new \midgard_query_storage('midgardmvc_core_node'));
$group = new midgard_query_constraint_group('AND');
$group->add_constraint(new \midgard_query_constraint(new \midgard_query_property('up'), '=', new \midgard_query_value($parent->id)));
$group->add_constraint(new \midgard_query_constraint(new \midgard_query_property('name'), '=', new \midgard_query_value($name)));
$q->set_constraint($group);
$q->execute();
$mvc_node = current($q->list_objects());
}
foreach ($node->childNodes as $snode) {
$this->append_nodes($snode, $mvc_node);
}
}
/**
* Simple default topic hierarchy setup for OpenPSA
*
* @package midcom
*/
function openpsa_prepare_topics()
{
$openpsa_topics = array('Calendar' => 'org.openpsa.calendar', 'Contacts' => 'org.openpsa.contacts', 'Documents' => 'org.openpsa.documents', 'Expenses' => 'org.openpsa.expenses', 'Invoices' => 'org.openpsa.invoices', 'Products' => 'org.openpsa.products', 'Projects' => 'org.openpsa.projects', 'Reports' => 'org.openpsa.reports', 'Sales' => 'org.openpsa.sales', 'User Management' => 'org.openpsa.user', 'Wiki' => 'net.nemein.wiki');
$qb = new midgard_query_builder('midgard_topic');
$qb->add_constraint('name', '=', 'openpsa');
$qb->add_constraint('up', '=', 0);
$topics = $qb->execute();
if ($topics) {
return $topics[0]->guid;
}
// Create a new root topic for OpenPSA
$root_topic = new midgard_topic();
$root_topic->name = 'openpsa';
$root_topic->component = 'org.openpsa.mypage';
$root_topic->extra = 'OpenPSA';
if (!$root_topic->create()) {
throw new Exception('Failed to create root topic for OpenPSA: ' . midgard_connection::get_instance()->get_error_string());
}
foreach ($openpsa_topics as $title => $component) {
$topic = new midgard_topic();
$topic->name = strtolower(preg_replace('/\\W/', '-', $title));
$topic->component = $component;
$topic->extra = $title;
$topic->up = $root_topic->id;
$topic->create();
}
return $root_topic->guid;
}
private function _prepare_database(\midgard_config $config)
{
$this->_io->write('Preparing storage <comment>(this may take a while)</comment>');
$midgard = \midgard_connection::get_instance();
$midgard->open_config($config);
if (!$midgard->is_connected()) {
throw new \Exception("Failed to open config {$config->database}:" . $midgard->get_error_string());
}
if (!$config->create_blobdir()) {
throw new \Exception("Failed to create file attachment storage directory to {$config->blobdir}:" . $midgard->get_error_string());
}
// Create storage
if (!\midgard_storage::create_base_storage()) {
if ($midgard->get_error_string() != 'MGD_ERR_OK') {
throw new \Exception("Failed to create base database structures" . $midgard->get_error_string());
}
}
$re = new \ReflectionExtension('midgard2');
$classes = $re->getClasses();
foreach ($classes as $refclass) {
if (!$refclass->isSubclassOf('midgard_object')) {
continue;
}
$type = $refclass->getName();
\midgard_storage::create_class_storage($type);
\midgard_storage::update_class_storage($type);
}
$this->_io->write('Storage created');
}
/**
* Handle the moving of a group phase
*
* @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_move($handler_id, array $args, array &$data)
{
$data['group'] = new midcom_db_group($args[0]);
// Get the prefix
$data['prefix'] = midcom_core_context::get()->get_key(MIDCOM_CONTEXT_ANCHORPREFIX);
if (isset($_POST['f_cancel'])) {
return new midcom_response_relocate("__mfa/asgard_midcom.admin.user/group/edit/{$data['group']->guid}/");
}
if (isset($_POST['f_submit'])) {
echo "<pre>\n";
print_r($_POST);
echo "</pre>\n";
$data['group']->owner = (int) $_POST['midcom_admin_user_move_group'];
if ($data['group']->update()) {
midcom::get('uimessages')->add($this->_l10n->get('midcom.admin.user'), midcom::get('i18n')->get_string('updated', 'midcom'));
return new midcom_response_relocate("__mfa/asgard_midcom.admin.user/group/edit/{$data['group']->guid}/");
} else {
debug_add('Failed to update the group, last midcom_connection::get_error_string was ' . midgard_connection::get_error_string(), MIDCOM_LOG_ERROR);
debug_print_r('We operated on this object', $data['group'], MIDCOM_LOG_ERROR);
throw new midcom_error('Failed to update the group, see error level log for details');
}
}
$data['view_title'] = sprintf($this->_l10n->get('move %s'), $data['group']->official);
midcom::get('head')->set_pagetitle($data['view_title']);
$this->_update_breadcrumb($handler_id);
}
private function midgard2Connect()
{
$filepath = ini_get('midgard.configuration_file');
$config = new \midgard_config();
$config->read_file_at_path($filepath);
$mgd = \midgard_connection::get_instance();
if (!$mgd->open_config($config)) {
throw new \PHPCR\RepositoryException($mgd->get_error_string());
}
return $mgd;
}
public function open_connection()
{
// Open connection
$midgard = midgard_connection::get_instance();
$this->config = new midgard_config();
$this->config->dbtype = $this->dbtype;
$this->config->database = 'midgardmvc_test';
$this->config->blobdir = "/tmp/midgardmvc_test";
$this->config->tablecreate = true;
$this->config->tableupdate = true;
$this->config->loglevel = 'warning';
if (!$midgard->open_config($this->config)) {
$this->markTestSkipped('Could not open Midgard connection to test database: ' . $midgard->get_error_string());
return false;
}
return true;
}
public function __construct()
{
if (ini_get('midgard.http') == 1) {
throw new LogicException("midgard.http should be set to 'Off', while running via AiP");
}
// opening connection
$filepath = get_cfg_var("midgard.configuration_file");
$config = new midgard_config();
$config->read_file_at_path($filepath);
$this->mgd = midgard_connection::get_instance();
$this->mgd->open_config($config);
// starting mvc
$application_config = get_cfg_var('midgardmvc.application_config');
if (!$application_config) {
$application_config = MIDGARDMVC_ROOT . '/application.yml';
}
$mvc = midgardmvc_core::get_instance($application_config);
}
/**
* Sets language, connectes signal handlers
*/
private function get_connected()
{
$this->mvc = midgardmvc_core::get_instance();
$this->mvc->i18n->set_translation_domain('com_meego_packages');
$default_language = $this->mvc->configuration->default_language;
if (!isset($default_language)) {
$default_language = 'en_US';
}
$this->mvc->i18n->set_language($default_language, false);
$request = $this->mvc->dispatcher->get_request();
//midgard_object_class::connect_default('midgard_attachment', 'action_loaded_hook', array('com_meego_packages_injector', 'register_download'), array($request));
midgard_object_class::connect_default('com_meego_ratings_rating', 'action_created', array('com_meego_packages_injector', 'register_rate_comment'), array($request));
midgard_object_class::connect_default('midgardmvc_ui_forms_form_instance', 'action_created', array('com_meego_packages_injector', 'register_qa_post'), array($request));
// Default title for Packages pages, override in controllers when possible
$this->mvc->head->set_title($this->mvc->i18n->get('title_apps'));
$_mc = midgard_connection::get_instance();
$res = $_mc->enable_replication(false);
$this->connected = true;
}
public function get_cache_directory()
{
$cache_root = null;
if (extension_loaded('midgard2')) {
$config = midgard_connection::get_instance()->config;
if ($config && $config->cachedir) {
$cache_root = $config->cachedir;
}
}
if (isset($_ENV['MIDGARD_ENV_GLOBAL_CACHEDIR'])) {
// Midgard Runtime
$cache_root = $_ENV['MIDGARD_ENV_GLOBAL_CACHEDIR'];
}
if (is_null($cache_root)) {
// Safe fallback, use /tmp
$cache_root = sys_get_temp_dir();
}
return str_replace('__MIDGARDCACHE__', $cache_root, $this->configuration['directory']);
}
<?php /** * @package midcom * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/ * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/ * @license http://www.gnu.org/licenses/gpl.html GNU General Public License */ require_once 'tools/bootstrap.php'; $GLOBALS['midcom_config_local']['log_level'] = 5; $GLOBALS['midcom_config_local']['log_filename'] = dirname(midgard_connection::get_instance()->config->logfilename) . '/midcom.log'; $GLOBALS['midcom_config_local']['midcom_root_topic_guid'] = openpsa_prepare_topics(); $GLOBALS['midcom_config_local']['auth_backend_simple_cookie_secure'] = false; $GLOBALS['midcom_config_local']['toolbars_enable_centralized'] = false;
public function run()
{
$config_file = "/etc/midgard2/conf.d/" . $this->_project_name;
if (file_exists($config_file)) {
switch ($this->prompt($config_file . " already exists, override?", 'n', array('y', 'n'))) {
case 'y':
unlink($config_file);
$config = $this->_create_config($config_file);
break;
default:
$config = new midgard_config();
if (!$config->read_file($this->_project_name, false)) {
$this->fail('Could not read config file ' . $config_file);
}
}
} else {
$config = $this->_create_config($config_file);
}
// Open a DB connection with the config
$midgard = midgard_connection::get_instance();
if (!$midgard->open_config($config)) {
$this->fail("Failed to open Midgard database connection to {$this->_project_name}: " . $midgard->get_error_string());
}
require_once 'tools/bootstrap.php';
openpsa_prepare_database($config);
openpsa_prepare_topics();
}
public function get_midgard_connection()
{
// Midgard 9.09 onwards
return midgard_connection::get_instance();
}
private function _complete_defaults()
{
if (midcom_connection::get('config', 'auth_cookie_id')) {
$auth_cookie_id = midcom_connection::get('config', 'auth_cookie_id');
} else {
// Generate host identifier from Midgard host
$auth_cookie_id = "host" . midcom_connection::get('host');
}
$this->_default_config['auth_backend_simple_cookie_id'] = $auth_cookie_id;
if (class_exists('Memcache')) {
$this->_default_config['cache_module_content_backend'] = array('driver' => 'memcached');
$this->_default_config['cache_module_memcache_backend'] = 'memcached';
}
if (isset($_SERVER['SERVER_ADDR'])) {
$this->_default_config['indexer_reindex_allowed_ips'][] = $_SERVER['SERVER_ADDR'];
}
$this->_default_config['midcom_site_title'] = $_SERVER['SERVER_NAME'];
$this->_default_config['toolbars_simple_css_path'] = MIDCOM_STATIC_URL . "/midcom.services.toolbars/simple.css";
$basedir = "/var/lib/midgard";
// TODO: Would be good to include DB name into the path
if (extension_loaded('midgard2')) {
$basedir = dirname(midgard_connection::get_instance()->config->sharedir);
} else {
$prefix = midcom_connection::get('config', 'prefix');
if ($prefix == '/usr/local') {
$basedir = '/var/local/lib/midgard';
}
}
$this->_default_config['midcom_services_rcs_root'] = $basedir . '/rcs';
}
<?php
$config_name = 'midgard';
$midgard = new midgard_connection();
if (!$midgard->open($config_name)) {
throw new Exception("Can not connect to database with given configuration " . $config_name);
}
$midgard->set_sitegroup('sg0');
$_MIDGARD['host'] = 0;
<?php
/**
* @package net_nemein_avaudu
* @author The Midgard Project, http://www.midgard-project.org
* @copyright The Midgard Project, http://www.midgard-project.org
* @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
*/
// Open connection
$midgard = new midgard_connection();
if (!$midgard->open('midgard')) {
die('Could not connect to Midgard database');
}
// Instantiate synchronizer
$sync = new net_nemein_avaudu_sync();
// Run synchronization in a loop that is initialized by App Builder instance launch
while (true) {
$sync->fetch_qaiku();
sleep(60);
}
/**
* Creates and returns a midgard_person object
*
*/
private function createUser($login)
{
# create the person object
$person = new midgard_person();
$person->firstname = $login;
$person->lastname = $login;
if (!$person->create()) {
$error = midgard_connection::get_instance()->get_error_string();
midgard_error::error(__CLASS__ . " Failed to create midgard person: " . $error);
return false;
} else {
midgard_error::info(__CLASS__ . " Created midgard person: " . $person->guid);
$user = new midgard_user();
$user->login = $login;
$user->password = '';
$user->usertype = 1;
$user->authtype = $this->config['default_auth_type'] ? $this->config['default_auth_type'] : 'SHA1';
$user->active = true;
$user->set_person($person);
if (!$user->create()) {
$error = midgard_connection::get_instance()->get_error_string();
midgard_error::error(__CLASS__ . "Failed to create midgard user: "******" Created midgard user: " . $user->login);
}
// @todo: not sure if this is the best solution;
// but it is simple to create midgardmvc_account objects
// this does not work, as we are not an MVC app
/*
$dummy_session = new midgardmvc_core_login_session();
$dummy_session->userid = '';
$dummy_session->username = $user->login;
$dummy_session->authtype = $user->authtype;
midgardmvc_account_injector::create_account_from_session($dummy_session);
unset($dummy_session);
*/
return $user;
}
<?php
/**
* Setup file for running unit tests
*
* Usage: phpunit --no-globals-backup ./
*/
$mgd_defaults = array('argv' => array(), 'user' => 0, 'admin' => false, 'root' => false, 'auth' => false, 'cookieauth' => false, 'page' => 0, 'debug' => false, 'self' => '/', 'prefix' => '', 'host' => 0, 'style' => 0, 'author' => 0, 'config' => array('prefix' => '', 'quota' => false, 'unique_host_name' => 'openpsa', 'auth_cookie_id' => 1), 'schema' => array('types' => array()));
$GLOBALS['midcom_config_local'] = array();
// Check that the environment is a working one
if (extension_loaded('midgard2')) {
$GLOBALS['midcom_config_local']['person_class'] = 'openpsa_person';
// Open connection
$midgard = midgard_connection::get_instance();
// Workaround for https://github.com/midgardproject/midgard-php5/issues/49
if (!$midgard->is_connected() && ($path = ini_get('midgard.configuration_file'))) {
$config = new midgard_config();
$config->read_file_at_path($path);
$midgard->open_config($config);
}
// if we still can't connect to a DB, we'll create a new one
if (!$midgard->is_connected()) {
$config = new midgard_config();
$config->dbtype = 'SQLite';
$config->database = 'openpsa_test';
$config->blobdir = OPENPSA_TEST_ROOT . '__output/blobs';
$config->logfilename = OPENPSA_TEST_ROOT . '__output/midgard2.log';
$config->tablecreate = true;
$config->tableupdate = true;
$config->loglevel = 'warn';
if (!$midgard->open_config($config)) {
function deletePost($message)
{
$args = $this->_params_to_args($message);
if (count($args) != 5) {
return new XML_RPC_Response(0, midcom_connection::get_error(), 'Invalid arguments.');
}
if (!midcom::get('auth')->login($args[2], $args[3])) {
return new XML_RPC_Response(0, midcom_connection::get_error(), 'Authentication failed.');
}
midcom::get('auth')->initialize();
try {
$article = new midcom_db_article($args[1]);
} catch (midcom_error $e) {
return new XML_RPC_Response(0, midcom_connection::get_error(), 'Article not found: ' . $e->getMessage());
}
if (!$article->delete()) {
return new XML_RPC_Response(0, midcom_connection::get_error(), 'Failed to delete article: ' . midgard_connection::get_error_string());
}
// Update the index
$indexer = midcom::get('indexer');
$indexer->delete($article->guid);
return new XML_RPC_Response(new XML_RPC_Value(true, 'boolean'));
}
/**
* Creates and returns a person object
*/
private function create_person($ldapuser = null, $tokens = null)
{
if (!$ldapuser) {
return false;
}
$person = new midgard_person();
$firstname = $ldapuser['firstname'];
$lastname = $ldapuser['lastname'];
if ($firstname == '' || $firstname == '--') {
$firstname = $tokens['login'];
}
if ($lastname == '' || $lastname == '--') {
$lastname = '';
}
$person->firstname = $firstname;
$person->lastname = $lastname;
if (!$person->create()) {
midgardmvc_core::get_instance()->log(__CLASS__, "Creating midgard_person for LDAP user failed: " . midgard_connection::get_instance()->get_error_string(), 'warning');
$transaction->rollback();
midgardmvc_core::get_instance()->authorization->leave_sudo();
return false;
}
$person->set_parameter('midgardmvc_core_services_authentication_ldap', 'employeenumber', $ldapuser['employeenumber']);
return $person;
}
* @copyright The Midgard Project, http://www.midgard-project.org
* @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
*/
/**
* Test that loads all components and dispatches each of their routes
*/
// Argument checks
if (count($argv) != 2) {
die("Usage: php find_orphans.php midgardconffile\n");
}
$conffile = $argv[1];
if (!extension_loaded('midgard') && !extension_loaded('midgard2')) {
die("Midgard extension is not available\n");
}
// Start up a Midgard connection
$midgard = new midgard_connection();
$midgard->open($conffile);
// Load MidCOM with the manual dispatcher
require 'midcom_core/framework.php';
$_MIDCOM = new midcom_core_midcom('manual');
echo "Loading all components and their routes\n\n";
// Go through the installed components
foreach ($_MIDCOM->componentloader->manifests as $component_name => $manifest) {
// Enter new context
$_MIDCOM->context->create();
try {
$_MIDCOM->dispatcher->initialize($component_name);
} catch (Exception $e) {
echo "Skipping {$component_name}: component failed to load\n\n";
$_MIDCOM->context->delete();
continue;
public function save()
{
// ConstraintViolationException
// TODO
// AccessDeniedException
// TODO
// LockException
// TODO
// VersionException
// TODO
$root_node = $this->getRootNode();
$children = $root_node->getNodes();
foreach ($children as $name => $child) {
if ($this->_node_save($child, $root_node) === false) {
$midgard_errcode = midgard_connection::get_instance()->get_error();
$midgard_errstr = midgard_connection::get_instance()->get_error_string();
switch ($midgard_errcode) {
case MGD_ERR_NAME_EXISTS:
throw new \PHPCR\ItemExistsException($midgard_errstr);
break;
case MGD_ERR_INVALID_NAME:
case MGD_ERR_INVALID_OBJECT:
case MGD_ERR_OBJECT_NO_PARENT:
case MGD_ERR_INVALID_PROPERTY_VALUE:
case MGD_ERR_INVALID_PROPERTY:
case MGD_ERR_TREE_IS_CIRCULAR:
throw new \PHPCR\InvalidItemStateException($midgard_errstr);
break;
case MGD_ERR_INTERNAL:
throw new \PHPCR\RepositoryException($midgard_errstr);
}
}
}
//NoSuchNodeTypeException
//ReferentialIntegrityException
}
public function get_midgard_connection()
{
return midgard_connection::get_instance();
}
public function get_midgard_connection()
{
if (method_exists('midgard_connection', 'get_instance')) {
// Midgard 9.09 onwards
return midgard_connection::get_instance();
}
if (!isset($_MIDGARD_CONNECTION)) {
return null;
}
// Midgard 8.09 or 9.03
return $_MIDGARD_CONNECTION;
}
/**
* Check if the current user is admin
*
* @return boolean True or false
*/
static function is_admin()
{
if (method_exists('midgard_connection', 'get_instance')) {
// Midgard 9.09 or newer
$user = midgard_connection::get_instance()->get_user();
} else {
// Midgard 8.09 or 9.03
$user = midgard_connection::get_user();
}
if (!$user) {
return false;
}
return $user->is_admin();
}
private function create_account(array $ldapuser, array $tokens)
{
midgardmvc_core::get_instance()->authorization->enter_sudo('midgardmvc_core');
$transaction = new midgard_transaction();
$transaction->begin();
$qb = new midgard_query_builder('midgard_person');
$qb->add_constraint('firstname', '=', $ldapuser['firstname']);
$qb->add_constraint('lastname', '=', $ldapuser['lastname']);
$persons = $qb->execute();
if (count($persons) == 0) {
$person = new midgard_person();
$person->firstname = $ldapuser['firstname'];
$person->lastname = $ldapuser['lastname'];
if (!$person->create()) {
midgardmvc_core::get_instance()->log(__CLASS__, "Creating midgard_person for LDAP user failed: " . midgard_connection::get_instance()->get_error_string(), 'warning');
$transaction->rollback();
midgardmvc_core::get_instance()->authorization->leave_sudo();
return false;
}
} else {
$person = $persons[0];
}
$person->set_parameter('midgardmvc_core_services_authentication_ldap', 'employeenumber', $ldapuser['employeenumber']);
$user = new midgard_user();
$user->login = $tokens['login'];
$user->password = '';
$user->usertype = 1;
$user->authtype = 'LDAP';
$user->active = true;
$user->set_person($person);
if (!$user->create()) {
midgardmvc_core::get_instance()->log(__CLASS__, "Creating midgard_user for LDAP user failed: " . midgard_connection::get_instance()->get_error_string(), 'warning');
$transaction->rollback();
midgardmvc_core::get_instance()->authorization->leave_sudo();
return false;
}
if (!$transaction->commit()) {
midgardmvc_core::get_instance()->authorization->leave_sudo();
return false;
}
midgardmvc_core::get_instance()->authorization->leave_sudo();
return true;
}
/**
* @todo: docs
*/
public function get_instance(array $args)
{
if (isset($args['project'])) {
$qbproject = com_meego_project::new_query_builder();
$qbproject->add_constraint('name', '=', $args['project']);
$projects = $qbproject->execute();
if (count($projects)) {
$project = $projects[0];
}
}
$qb = com_meego_package::new_query_builder();
$qb->add_constraint('name', '=', $args['package']);
$qb->add_constraint('version', '=', $args['version']);
$qb->add_constraint('repository.project', '=', $project->id);
$qb->add_constraint('repository.name', '=', $args['repository']);
$qb->add_constraint('repository.arch', '=', $args['arch']);
$packages = $qb->execute();
if (count($packages) == 0) {
throw new midgardmvc_exception_notfound("Package not found");
}
$this->data['package'] = $packages[0];
if (empty($this->data['package']->title)) {
$this->data['package']->title = $this->data['package']->name;
}
$this->data['package']->description = str_replace("\n\n", "<br /><br />", $this->data['package']->description);
if ($this->data['package']->category) {
$qb = com_meego_package_category::new_query_builder();
$qb->add_constraint('id', '=', $this->data['package']->category);
$categories = $qb->execute();
if (count($categories) == 0) {
throw new midgardmvc_exception_notfound("Package category not found");
}
$this->data['package']->category_name = $categories[0]->name;
while ($categories[0]->up != 0) {
$qb = com_meego_package_category::new_query_builder();
$qb->add_constraint('id', '=', $categories[0]->up);
$categories = $qb->execute();
if (count($categories) == 0) {
throw new midgardmvc_exception_notfound("Package parent category not found");
}
$this->data['package']->category_name = $categories[0]->name . "/" . $this->data['package']->category_name;
}
} else {
$this->data['package']->category_name = "";
}
// get license info
$license = new com_meego_license($this->data['package']->license);
$this->data['package']->licensename = $license->name;
$this->data['package']->licenseurl = $license->url;
$this->data['package']->localurl = $this->mvc->dispatcher->generate_url('package', array('package' => $this->data['package']->name), $this->request);
$this->data['package']->repositoryobject = new com_meego_repository($this->data['package']->repository);
$this->data['package']->repositoryobject->localurl = $this->mvc->dispatcher->generate_url('repository', array('project' => $args['project'], 'repository' => $this->data['package']->repositoryobject->name, 'arch' => $this->data['package']->repositoryobject->arch), $this->request);
$this->data['package']->iconurl = false;
$this->data['package']->screenshoturl = false;
$attachments = $this->data['package']->list_attachments();
$_icon_marker = 'icon.png';
$_screenshot_marker = 'screenshot.png';
foreach ($attachments as $attachment) {
if ($attachment->mimetype == 'image/png') {
if (strrpos($attachment->name, $_screenshot_marker) !== false && !$this->data['package']->screenshoturl) {
$this->data['package']->screenshoturl = $this->mvc->dispatcher->generate_url('attachmentserver_variant', array('guid' => $attachment->guid, 'variant' => 'prop480x300', 'filename' => $attachment->name), '/');
}
if (strrpos($attachment->name, $_icon_marker) !== false && !$this->data['package']->iconurl) {
$this->data['package']->iconurl = $this->mvc->dispatcher->generate_url('attachmentserver_variant', array('guid' => $attachment->guid, 'variant' => '', 'filename' => $attachment->name), '/');
}
}
}
$storage = new midgard_query_storage('com_meego_package_relation');
$q = new midgard_query_select($storage);
$q->set_constraint(new midgard_query_constraint(new midgard_query_property('from', $storage), '=', new midgard_query_value($this->data['package']->id)));
$res = $q->execute();
if ($res != 'MGD_ERR_OK') {
$_mc = midgard_connection::get_instance();
echo "Error received from midgard_connection: " . $_mc->get_error_string() . "\n";
return;
}
$relations = $q->list_objects();
/* maps relation types to human parsable names */
$typemap = array('requires' => 'Requires', 'buildrequires' => 'Build requires', 'obsoletes' => 'Obsoletes', 'conflicts' => 'Conflicts', 'provides' => 'Provides');
$this->data['relations'] = array();
foreach ($relations as $relation) {
$_url = false;
$_title = $relation->relation;
if (!isset($this->data['relations'][$relation->relation])) {
$this->data['relations'][$relation->relation] = array('title' => $_title, 'packages' => array());
}
$_relpackage = null;
$storage = new midgard_query_storage('com_meego_package_details');
$q = new midgard_query_select($storage);
$q->set_constraint(new midgard_query_constraint(new midgard_query_property('packageid', $storage), '=', new midgard_query_value($relation->to)));
$q->execute();
$_packages = $q->list_objects();
if (count($_packages)) {
$_relpackage = $_packages[0];
}
if ($_relpackage) {
$_url = $this->mvc->dispatcher->generate_url('package_instance', array('package' => $relation->toname, 'version' => $relation->version, 'project' => $args['project'], 'repository' => $_relpackage->reponame, 'arch' => $_relpackage->repoarch), $this->request);
}
$_relation = $relation;
if (array_key_exists($relation->relation, $typemap)) {
$this->data['relations'][$relation->relation]['title'] = $typemap[$relation->relation] . ':';
}
$_relation->localurl = $_url;
array_push($this->data['relations'][$relation->relation]['packages'], $_relation);
}
unset($relations, $relation, $_relation, $_url, $typemap);
if (!$this->data['package']->packagehidden) {
$list_of_workflows = midgardmvc_helper_workflow_utils::get_workflows_for_object($this->data['package']);
}
// @todo: get completed workflows and offer an index page for admins
// to list of forms and get an accumulated result
$this->data['workflows'] = array();
foreach ($list_of_workflows as $workflow => $workflow_data) {
$this->data['workflows'][] = array('label' => $workflow_data['label'], 'url' => $this->mvc->dispatcher->generate_url('package_instance_workflow_start', array('package' => $this->data['package']->name, 'version' => $this->data['package']->version, 'project' => $args['project'], 'repository' => $args['repository'], 'arch' => $args['arch'], 'workflow' => $workflow), $this->request), 'css' => $workflow_data['css']);
}
// get the ratings for this package
// enable if the template does not use dynamic loading
// $this->data['package']->ratings = self::prepare_ratings($this->data['package']->guid);
}
<?php
$midgard = new midgard_connection();
$midgard->open('midgard');
@ini_set('max_execution_time', 0);
// Figure out when sequence was updated last time
$qb = new midgard_query_builder('midgard_sequence');
$qb->set_limit(1);
$qb->add_order('id', 'DESC');
$transactions = $qb->execute();
if (count($transactions) == 0) {
$latest_sequence = new midgard_datetime('0000-00-00');
} else {
foreach ($transactions as $transaction) {
$latest_sequence = $transaction->metadata->created;
}
}
$sequence = array();
foreach ($_MIDGARD['schema']['types'] as $type => $val) {
if (substr($type, 0, 2) == '__') {
continue;
}
// Updated objects
$qb = new midgard_query_builder($type);
$qb->add_constraint('metadata_revised', '>', $latest_sequence);
$qb->add_order('metadata_revised', 'ASC');
$objects = $qb->execute();
foreach ($objects as $object) {
$revised = $object->metadata->revised->format(DATE_ATOM);
$sequence["{$revised}_{$object->guid}"] = array('objectguid' => $object->guid, 'type' => $type, 'revision' => $object->metadata->revision);
}