tag were used.
if (!$success || !$vals || $vals[0]['tag'] != 'PATTERN' || $vals[1]['tag'] != 'INFO') {
form_set_error('xmlsource', t('Error parsing the XML, please check your syntax and try again.'));
}
}
function patterns_import_submit($form, &$form_state) {
if (isset($form_state['pattern_file'])) {
$saved = file_copy($form_state['pattern_file']->filepath, $form_state['pattern_file']->destination);
}
else if ($form_state['values']['xmlsource']) {
$saved = file_save_data($form_state['values']['xmlsource'], variable_get('patterns_save_xml', 'patterns') .'/'. $form_state['values']['xmlname'] .'.xml', FILE_EXISTS_REPLACE);
}
if ($saved) {
// Reload patterns
patterns_get_patterns(true);
drupal_set_message('Pattern successfully imported.');
}
else {
drupal_set_message("File couldn't be saved on the server. Import failed.", 'error');
}
$form_state['redirect'] = 'admin/build/patterns';
}
function patterns_list() {
drupal_add_css(drupal_get_path('module', 'patterns') .'/patterns.css');
drupal_add_js(drupal_get_path('module', 'patterns') .'/patterns.js');
patterns_load_components();
$patterns = patterns_get_patterns();
if (empty($patterns)) return t('No patterns available.');
// $header = array(t('Title'), t('Status'), t('Version'), t('Public'), t('Actions'));
$header = array(t('Title'), t('Status'), t('Version'), t('Actions'));
// List all patterns
$rows = array();
foreach($patterns as $pid => $pattern) {
$actions = array();
if (!$pattern->status) {
$actions[] = l(t('Run'), 'admin/build/patterns/enable/'. $pid);
}
else if ($pattern->enabled >= $pattern->updated) {
$actions[] = l(t('Re-Run'), 'admin/build/patterns/enable/'. $pid);
}
else {
$actions[] = l(t('Run Update'), 'admin/build/patterns/enable/'. $pid);
}
$actions[] = l(t('Edit'), 'admin/build/patterns/edit/'. $pid);
if (variable_get('patterns_allow_publish', FALSE)) {
$actions[] = $pattern->public ? l(t('Unpublish'), 'admin/build/patterns/unpublish/'. $pid) : l(t('Publish'), 'admin/build/patterns/publish/'. $pid);
}
$actions = implode(' ', $actions);
$cells = array();
// $title = l($pattern->title, 'admin/build/patterns/info/'. $pid, array('attributes' => array('class' => 'pattern-title', 'id' => 'pid-'. $pid)));
$title = ''. $pattern->title .'';
// $view_more = ''. t('Clik on pattern title to see more details.') .'
';
$info = array();
$info[] = t('Author: ') . $pattern->info['author'];
$info[] = t('Email: ') . $pattern->info['author_email'];
$info[] = t('Web: ') . $pattern->info['author_website'];
$author = theme('item_list', $info);
$title .= ''. $author . $pattern->description . $view_more .'
';
$cells[] = array('data' => $title, 'class' => 'title');
$cells[] = array('data' => $pattern->status ? t('Enabled') : t('Disabled'), 'class' => 'status');
$cells[] = array('data' => $pattern->info['version'], 'class' => 'version');
// $cells[] = $pattern->public ? t('Yes') : t('No');
$cells[] = array('data' => $actions, 'class' => 'actions');
$category = $pattern->info['category'] ? $pattern->info['category'] : t('Other');
$rows[$category][] = $cells;
}
ksort($rows);
foreach ($rows as $title => $category) {
$fieldset = array(
'#title' => t($title),
'#collapsible' => TRUE,
'#collapsed' => FALSE,
'#value' => theme('table', $header, $category, array('class' => 'patterns-list')),
);
$output .= theme('fieldset', $fieldset);
}
return $output;
}
/**
* Menu callback to undo a patterns update changes
*/
// function patterns_revert($pid) {
// if ($name = db_result(db_query('SELECT name FROM {patterns} WHERE pid = "%d"', $pid))) {
// $path = file_create_path(variable_get('patterns_save_xml', 'patterns') .'/enabled/'. $name .'.xml');
// $new = db_result(db_query('SELECT file FROM {patterns} WHERE pid = "%d"'));
// }
// else {
// drupal_set_message(t('The pattern you specified does not exist.'), 'error');
// drupal_goto('admin/build/patterns');
// }
//
// if (file_exists($path)) {
// if (file_move($path, $new, FILE_EXISTS_REPLACE)) {
// drupal_set_message(t('This pattern was reverted to the state it was at when it was enabled.'));
// drupal_goto();
// }
// }
// else {
// drupal_set_message(t('The patterns enabled-state was not saved properly, therefore it cannot be reverted.'), 'error');
// }
//
// drupal_goto('admin/build/patterns');
// }
/**
* Menu callback to display patterns details page
*/
// function patterns_info($pid = null) {
// if (!is_numeric($pid)) {
// drupal_set_message(t('You must specify a pattern.'));
// return;
// }
//
// $pattern = patterns_get_pattern($pid);
//
// $output = '';
// return $output;
// }
/**
* Menu callback to edit a patterns data
*/
function patterns_edit(&$form_state, $pid = null) {
if (!is_numeric($pid)) {
drupal_set_message(t('You must specify a pattern to edit.'));
return;
}
$pattern = patterns_get_pattern($pid);
// TODO: Turn php into xml here.
// For now just allow modifying the original xml, which
// means the modification cannot be further modified
if (!$pattern->file) {
drupal_set_message(t('This pattern does not seem to have an XML source file to base the modifications off of.'), 'error');
return;
}
$xml = file_get_contents($pattern->file);
$form['name'] = array(
'#type' => 'value',
'#value' => $pattern->name
);
$form['pid'] = array(
'#type' => 'value',
'#value' => $pattern->pid
);
// if ($pattern->enabled <= $pattern->updated) {
// $form['revert'] = array(
// '#type' => 'markup',
// '#value' => l(t('Undo update changes to the state when you enabled the pattern.'), 'admin/build/patterns/revert/'. $pid, array(), drupal_get_destination())
// );
// }
$form['format'] = array(
'#type' => 'select',
'#title' => t('Pattern syntax'),
'#options' => array_combine(patterns_file_types(), patterns_file_types()),
'#default_value' => 'xml'
);
$form['xml'] = array(
'#type' => 'textarea',
'#title' => t('Pattern\'s code'),
'#rows' => 25,
'#default_value' => $xml
);
$form['submit'] = array(
'#type' => 'submit',
'#value' => t('Submit')
);
return $form;
}
/**
* Validate pattern modifications (make sure proper XML)
*/
function patterns_edit_validate($form, &$form_state) {
// @TODO Do validations....
$path = file_create_path(variable_get('patterns_save_xml', 'patterns'));
if (!file_check_directory($path, true)) {
form_set_error('form_token', t('Unable to create @path to save the new pattern to.', array('@path' => $path)));
}
}
/**
* Submit edits to the pattern
*/
function patterns_edit_submit($form, &$form_state) {
// If this is an enabled pattern, make sure the enabled pattern is saved in its current state
if ($file = db_result(db_query('SELECT file FROM {patterns} WHERE status = 1 AND name = "%s"', $form_state['values']['name']))) {
$dir = file_directory_path() .'/'. variable_get('patterns_save_xml', 'patterns') .'/enabled';
file_check_directory($dir, true);
$path = $dir .'/'. $form_state['values']['name'] .'.'. $form_state['values']['format'];
if (!file_exists($path)) {
file_copy($file, $path, FILE_EXISTS_ERROR);
}
}
// Save the new pattern into the pattern files dir.
$path = file_directory_path() .'/'. variable_get('patterns_save_xml', 'patterns') .'/'. $form_state['values']['name'] .'.'. $form_state['values']['format'];
file_save_data($form_state['values']['xml'], $path, FILE_EXISTS_REPLACE);
$old = db_result(db_query('SELECT file FROM {patterns} WHERE name = "%s"', $form_state['values']['name']));
// Load and save pattern
$load_func = 'patterns_load_' .$form_state['values']['format'];
if ($pattern = $load_func($path)) {
if ($old) {
db_query('UPDATE {patterns} SET file = "%s", updated = "%s" WHERE pid = "%d"', $path, time(), $form_state['values']['pid']);
}
patterns_save_pattern($pattern, $path, $form_state['values']['name']);
drupal_set_message(t('%name was saved.', array('%name' => $form_state['values']['name'])));
$form_state['redirect'] = 'admin/build/patterns';
}
else {
drupal_set_message(t("Pattern '%name' couldn't be saved. Make sure edited code is well-formed.", array('%name' => $form_state['values']['name'])), 'error');
}
}
/**
* List the modules used by a particular pattern
*/
function patterns_modules_page($pid) {
$pattern = patterns_get_pattern($pid);
drupal_set_title($pattern->title .' '. t('(Pattern Modules)'));
$modules = isset($pattern->pattern['modules']) ? $pattern->pattern['modules'] : array();
$modules_info = module_rebuild_cache();
$modules_list = module_list();
// Get module name, whether its to be disabled or enabled,
// whether the module is available or not, and whether it is
// currently enabled or not
foreach($modules as $module) {
$row = array();
$delete = is_array($module) ? $module['delete'] : false;
$module = is_array($module) ? $module['value'] : $module;
$available = array_key_exists($module, $modules_info);
$enabled = array_key_exists($module, $modules_list);
$row[] = $module;
$row[] = $available ? t('Yes') : ''. t('No') .'';
$row[] = $enabled ? t('Yes') : ''. t('No') .'';
$row[] = $delete ? t('Delete') : t('Enable');
$rows[] = $row;
if (!$available) {
$not_available = true;
}
}
if ($not_available) {
drupal_set_message(t('Some modules are not availalble, please download them before running this pattern.'), 'error');
}
else {
drupal_set_message(t('All modules required by this module are available. Click !here to run this pattern.', array('!here' => l(t('here'), 'admin/build/patterns/enable/'. $pid))));
}
return theme('table', array(t('Name'), t('Available'), t('Enabled'), t('Pattern Action')), $rows, t('Modules used for this pattern'));
}
function patterns_load_components() {
static $loaded = false;
if ($loaded) {
return;
}
require_once drupal_get_path('module', 'patterns') .'/patterns.inc';
// Get a list of directories to search
$paths = module_invoke_all('patterns_directory');
foreach($paths as $path) {
foreach(file_scan_directory($path .'/components', '.\.inc$') as $file) {
include_once $file->filename;
}
}
$loaded = true;
}
function patterns_get_patterns($reset = true) {
patterns_load_components();
if ($reset || !variable_get('patterns_loaded', false)) {
// Get a listing of enabled patterns
$enabled = array();
$result = db_query('SELECT file FROM {patterns} WHERE status = 1');
while ($pattern = db_fetch_object($result)) {
$enabled[] = $result->file;
}
$priority = array();
$errors = array();
// Get list of directories to scan for patterns
$patterns_paths = patterns_paths();
// get valid file extensions
$mask = '.\.('. implode('|', patterns_file_types()) .')$';
// prepare list of files/folders to be excluded
// 'enabled' - Don't save enabled pattern backups
$no_mask = array('.', '..', 'CVS', '.svn', 'enabled');
foreach ($patterns_paths as $path) {
foreach(file_scan_directory($path, $mask, $no_mask) as $file) {
// Can't update existing patterns that are enabled
if (in_array($file->filename, $enabled) || in_array($file->name, $priority)) {
continue;
}
$priority[] = $file->name;
// choose appropriate function based on the file extension
$func = 'patterns_load_'. substr($file->basename, strlen($file->name) + 1);
// Load and save pattern
if ($pattern = $func($file->filename)) {
patterns_save_pattern($pattern, $file->filename, $file->name);
}
else {
$errors[] = $file->filename;
}
}
}
variable_set('patterns_loaded', time());
}
$result = db_query('SELECT * FROM {patterns}');
$messages = array();
while ($pattern = db_fetch_object($result)) {
// skip pattern if its file is missing
if (!is_file($pattern->file)) continue;
// skip pattern if loading failed and report that to the user
if (in_array($pattern->file, $errors)) {
$messages[] = t("Pattern couldn't be loaded from the file '%file'", array('%file' => $pattern->file));
continue;
}
$patterns[$pattern->pid] = $pattern;
$data = unserialize($pattern->pattern);
$patterns[$pattern->pid]->pattern = $data;
$patterns[$pattern->pid]->info = $data['info'];
}
if (!empty($messages)) {
drupal_set_message(implode('
', $messages) .'
'. t('Make sure that above file(s) are readable and contain valid data.'), 'error');
}
return $patterns;
}
/**
* return a list of paths that will be scanned for patterns
*/
function patterns_paths() {
$path = file_create_path(variable_get('patterns_save_xml', 'patterns'));
global $profile;
if (!isset($profile)) {
$profile = variable_get('install_profile', 'default');
}
// array of all the paths where we should look for patterns
$patterns_paths = array(
conf_path() .'/patterns',
'profiles/'. $profile .'/patterns',
'sites/all/patterns'
);
// allow any module to include patterns too
foreach(module_invoke_all('patterns_directory') as $path) {
if (is_dir($path)) {
$patterns_paths[] = $path .'/patterns';
}
}
// also prepend files folder if it's valid
if (file_check_directory($path)) {
array_unshift($patterns_paths, $path);
}
return $patterns_paths;
}
/**
* Implementation of hook_patterns_directory()
*
* Let us know about where the pattern files are at
*/
function patterns_patterns_directory() {
return drupal_get_path('module', 'patterns');
}
function patterns_save_pattern($pattern, $path = '', $name = '') {
$title = $pattern['info']['title'];
$description = $pattern['info']['description'];
$author = $pattern['info']['author'];
if ($pid = db_result(db_query('SELECT pid FROM {patterns} WHERE name = "%s"', $name))) {
$updated = db_result(db_query('SELECT updated FROM {patterns} WHERE pid = "%d"', $pid));
if (($new_updated = filemtime($path)) > $updated) {
db_query('UPDATE {patterns} SET pattern = "%s", title = "%s", file = "%s", updated = "%s", description = "%s" WHERE pid = %d', serialize($pattern), $title, $path, $new_updated, $description, $pid);
}
else {
db_query('UPDATE {patterns} SET pattern = "%s", title = "%s", file = "%s", description = "%s" WHERE pid = %d', serialize($pattern), $title, $path, $description, $pid);
}
}
else {
db_query('INSERT INTO {patterns} (name, status, file, updated, enabled, title, description, pattern) VALUES ( "%s", 0, "%s", "%s", 0, "%s", "%s", "%s")', $name, $path, time(), $title, $description, serialize($pattern));
}
}
function patterns_get_pattern($id) {
if (is_numeric($id)) {
$pattern = db_fetch_object(db_query('SELECT * FROM {patterns} WHERE pid = "%d"', $id));
}
else if (is_string($id)) {
$pattern = db_fetch_object(db_query('SELECT * FROM {patterns} WHERE name = "%s"', $id));
}
if (!$pattern) return FALSE;
// Get the actual data. Data is stored in serialized form in the db.
$pattern->pattern = unserialize($pattern->pattern);
return $pattern;
}
/**
* Check if pattern array contains only allowed keys
*
* @param $pattern
* pattern array obtained by parsing pattern file
* @return
* TRUE when only allowed array keys are found, FALSE otherwise
*
* @todo expand this function to include much more detailed validation
*/
function patterns_validate_pattern($pattern) {
if (empty($pattern)) {
return FALSE;
}
$allowed_keys = array('info', 'modules', 'actions');
$diff = array_diff(array_keys($pattern), $allowed_keys);
return empty($diff) ? TRUE : FALSE;
}
/**
* Return file extensions supported by patterns module
*
* @return array of supported file types
*
* @todo convert this into pluggable system
*/
function patterns_file_types() {
$result = array('xml', 'php');
if (file_exists(drupal_get_path('module', 'patterns') .'/spyc/spyc.php')) {
$result[] = 'yaml';
}
return $result;
}
function patterns_load_yaml($path, $local = TRUE) {
if ($local && !file_exists($path)) {
return FALSE;
}
include_once 'spyc/spyc.php';
$pattern = Spyc::YAMLLoad($path);
if (!patterns_validate_pattern($pattern)) {
return FALSE;
}
return $pattern;
}
function patterns_load_string_yaml($source) {
// loading yaml from source doesn't preserve line breaks
// so we need to save it as a file first
$path = file_directory_temp() .'/import.yaml';
file_save_data($source, $path, FILE_EXISTS_REPLACE);
$pattern = patterns_load_yaml($path);
unlink($path);
return $pattern;
}
function patterns_load_xml($path, $local = TRUE) {
if ($local && !file_exists($path)) {
return FALSE;
}
if (!$xml = file_get_contents($path)) {
return FALSE;
}
return patterns_load_string_xml($xml);
}
function patterns_load_string_xml($source) {
$pattern = patterns_from_source($source);
if (empty($pattern) || $pattern['tag'] != 'pattern') {
return FALSE;
}
// Rearrange the data in a nice way for each component.
// Make sure actions are processed differently so order is preserved.
$pattern = patterns_rearrange_data($pattern);
foreach($pattern as $key => $values) {
$pattern[$values['tag']] = $values;
unset($pattern[$values['tag']]['tag']);
unset($pattern[$key]);
}
if (!patterns_validate_pattern($pattern)) {
return FALSE;
}
return $pattern;
}
/**
* Read and evaluate a php file to return a 'pattern'
*/
function patterns_load_php($path, $local = TRUE) {
if ($local && !file_exists($path)) {
return FALSE;
}
$pattern = array();
@include($path);
// That should have declared a 'pattern' into current scope.
if (!patterns_validate_pattern($pattern)) {
trigger_error("Failed to evaluate a useful pattern from the input file $path. Pattern did not validate. May have been invalid syntax. ", E_USER_WARNING);
return FALSE;
}
return $pattern;
}
/**
* Create a pattern from an XML data source
*/
function patterns_from_source($xml) {
$parse = drupal_xml_parser_create($xml);
if (!xml_parse_into_struct($parse, $xml, $vals, $index)) {
return false;
}
// Create a multi-dimensional array representing the XML structure
$pattern = current(_patterns_parse_tag($vals));
return $pattern;
}
/**
* Recurse through the values of a parsed xml file to create a
* multi-dimensional representation of the data.
*/
function _patterns_parse_tag($data, &$index = 0) {
$pattern = array();
while ($current = $data[$index]) {
$type = $current['type'];
foreach((array)$current['attributes'] as $key => $value) {
$current[strtolower($key)] = $value;
}
$current['tag'] = strtolower($current['tag']);
unset($current['type'], $current['level'], $current['attributes']);
if (!trim($current['value']) && $current['value'] != "0") {
unset($current['value']);
}
switch($type) {
case 'open':
$index++;
$current += _patterns_parse_tag($data, $index);
$pattern[] = $current;
break;
case 'close':
$index++;
return $pattern;
break;
case 'complete':
// In order to support more complex/non-standard features we can use serialized data
if ($current['attributes']['serialized']) {
$value = unserialize($current['value']);
if (isset($value)) {
$current['value'] = $value;
}
}
// If no value was specified, make sure an empty value is there
if (!isset($current['value'])) {
$current['value'] = '';
}
$pattern[] = $current;
break;
}
$index++;
}
return $pattern;
}
// function patterns_disable_pattern($pid) {
// $form['pid'] = array(
// '#type' => 'value',
// '#value' => $pid
// );
//
// $pattern = patterns_get_pattern($pid);
//
// return confirm_form($form, t('Proceed with disabling pattern %pattern?', array('%pattern' => $pattern->title)), 'admin/build/patterns', '');
// }
function patterns_enable_pattern(&$form_state, $pid) {
$form['pid'] = array(
'#type' => 'value',
'#value' => $pid
);
$disclaimer = t('Please be sure to backup your site before running a pattern. Patterns are not guaranteed to be reversable in case they do not execute well or if unforseen side effects occur.');
$pattern = patterns_get_pattern($pid);
return confirm_form($form, t('Proceed with running pattern %pattern?', array('%pattern' => $pattern->title)), 'admin/build/patterns', $disclaimer);
}
// function patterns_disable_pattern_submit($form_id, $form_values) {
// $pid = $form_values['pid'];
// $pattern = patterns_get_pattern($pid);
//
// if (patterns_execute_pattern($pattern, true, true)) {
// return 'admin/build/patterns';
// }
// }
function patterns_enable_pattern_submit($form, &$form_state) {
$pid = $form_state['values']['pid'];
patterns_load_components();
$pattern = patterns_get_pattern($pid);
patterns_execute_pattern($pattern, $form_state['values']);
$form_state['redirect'] = 'admin/build/patterns';
}
/**
* Execute default configuration for module during the module installation
*
* This function should be called by other modules from
* within their hook_enable() implementation.
* Module should also provide modulename.config file containing PHP array
* with the actions that need to be executed.
*
* @param $module
* name of the module calling the function
*/
function patterns_execute_config($module) {
// since this function is called from hook_enable(), we need to ensure that
// it's executed only at module installation (first time module is enabled)
if (drupal_get_installed_schema_version($module) == SCHEMA_INSTALLED) return;
$path = drupal_get_path('module', $module) .'/'. $module .'.config';
if (file_exists($path)) {
include_once($path);
if (empty($actions)) return;
$pattern = new stdClass();
$pattern->title = t('Default configuration for @module module', array('@module' => $module));
$pattern->status = false;
$pattern->pattern['actions'] = $actions;
patterns_execute_pattern($pattern);
}
}
function patterns_execute_pattern($pattern, $params = array(), $mode = 'batch') {
$args = array($pattern, $params);
$function = 'patterns_execute_pattern_'. $mode;
if (!function_exists($function) || !is_object($pattern)) return FALSE;
return call_user_func_array($function, $args);
}
function patterns_execute_pattern_batch($pattern, $params = array()) {
set_time_limit(0);
if (!is_object($pattern)) {
$pattern = patterns_get_pattern($pattern);
if (!$pattern) {
return FALSE;
}
}
$pattern_details = patterns_get_pattern_details($pattern, TRUE);
$modules = $pattern_details['modules'];
$actions = $pattern_details['actions'];
$actions_map = array('patterns' => $pattern_details['info'], 'map' => $pattern_details['actions_map']);
$info = reset($pattern_details['info']);
// If there are no actions or modules, most likely the pattern
// was not created correctly.
if (empty($actions) && empty($modules)) {
drupal_set_message(t('Could not recognize pattern %title, aborting.', array('%title' => $info['title'])), 'error');
return FALSE;
}
$result = patterns_install_modules($modules);
if (!$result['success']) {
drupal_set_message($result['error_message'], 'error');
return FALSE;
}
$result = patterns_prepare_actions($actions, $actions_map);
if (!$result['success']) {
drupal_set_message($result['error_message'], 'error');
return FALSE;
}
$batch = array(
'title' => t('Processing pattern %pattern', array('%pattern' => $info['title'])),
// 'init_message' => t('Running action @current out of @total', array('@current' => 1, '@total' => count($actions))),
'progress_message' => t('Running action @current out of @total'),
'operations' => array(),
'finished' => 'patterns_batch_finish'
);
for($i=0;$i TRUE);
if (empty($modules)) return $result;
$missing = patterns_check_module_dependencies($modules, TRUE);
if (!empty($missing)) {
$result['success'] = FALSE;
$result['error_message'] = t('Following required modules are missing: %modules', array('%modules' => implode(', ', $missing)));
$result['missing_modules'] = $missing;
return $result;
}
require_once './includes/install.inc';
drupal_install_modules($modules);
module_rebuild_cache();
$result['installed_modules'] = $modules;
return $result;
}
function patterns_locate_action($key, $actions_map) {
$result['key'] = $actions_map['map'][$key]['index'];
$result['title'] = $actions_map['patterns'][$actions_map['map'][$key]['pid']]['title'];
$result['file'] = $actions_map['patterns'][$actions_map['map'][$key]['pid']]['file'];
return $result;
}
function patterns_prepare_actions(&$actions, $actions_map) {
$result = array('success' => TRUE);
if (empty($actions)) return $result;
patterns_load_components();
// Keep a list of what modules handle what tags
$tag_modules = patterns_invoke($empty, 'tag modules');
// TODO Finish basic setup and execution of the 'config' operation
// TODO Make a better streamlined config framework process. For instance collect form_ids
// from here and give the form_id and matching data to the 'build' process
foreach($actions as $key => &$data) {
if (($config = patterns_invoke($actions[$key], 'config')) && !empty($config)) {
patterns_config_data($data, $config);
}
}
// Prepare actions for validation/processing
foreach($actions as $key => &$data) {
patterns_invoke($actions[$key], 'prepare');
}
// Pre validate tags with their appropriate components
foreach($actions as $key => &$data) {
$action_location = patterns_locate_action($key, $actions_map);
$index = $action_location['key'];
$pattern_title = $action_location['title'];
// $pattern_file = $action_location['file'];
if (!array_key_exists($data['tag'], $tag_modules)) {
$errors[] = t('Action #%num (%tag) in pattern %title: <%tag> is not a valid tag', array('%num' => $index+1, '%tag' => $data['tag'], '%title' => $pattern_title));
}
else {
$error = patterns_invoke($actions[$key], 'pre-validate');
if ($error) {
$errors[] = t('Action #%num (%tag) in pattern %title: !msg', array('!msg' => $error, '%num' => $index+1, '%tag' => $data['tag'], '%title' => $pattern_title));
}
}
}
if (count($errors)) {
$message = t('Errors encountered during pre-processing:') .'
'. implode('
', $errors);
$result['success'] = FALSE;
$result['error_message'] = $message;
}
return $result;
}
/**
* Execute a batch action
*/
function patterns_batch_actions($action, $place, $actions_map, &$context) {
patterns_load_components();
// Nothing to do if there is no action
if (empty($action)) {
$context['finished'] = 1;
return;
}
// Start a timer. Since we want each action to be its own http request, we need
// to ensure the batch api will decide to do it like that by making each action
// take at least a second to execute
timer_start('patterns_action');
// skip action execution if an error is encountered in some of the previous operations
if (!empty($context['results']['abort'])) return;
$result = patterns_implement_action($action, $context['results']['identifiers'], $place, $actions_map);
if (!$result['success']) {
// we use 'results' to keep track of errors and abort execution if required
$context['results']['abort'] = TRUE;
$context['results']['error_message'] = $result['error_message'];
}
if (timer_read('patterns_action') < 1000) {
@usleep(1000 - timer_read('patterns_action'));
}
}
/**
* Finish a batch operation
*/
function patterns_batch_finish($success, $results, $operations) {
$info = $_SESSION['patterns_batch_info'];
if (!($results['abort'])) {
foreach ($info as $key => $i) {
drupal_set_message(t('Pattern "@pattern" ran successfully.', array('@pattern' => $i['title'])));
db_query('UPDATE {patterns} SET status = 1, enabled = "%s" WHERE pid = %d', time(), $key);
}
}
else {
$pattern = reset($info);
drupal_set_message(t('Pattern "@pattern" ran with the errors. Check the error messages to get more details.', array('@pattern' => $pattern['title'])));
drupal_set_message($results['error_message'], 'error');
}
unset($_SESSION['patterns_batch_info']);
drupal_flush_all_caches();
}
/**
* Setup and run an action
*/
function patterns_implement_action($action, &$identifiers, $place = 0, $actions_map = NULL) {
patterns_set_error_handler();
$result = array('success' => TRUE);
// Prepare actions for processing, ensure smooth pattern executions, and return form ids for execution
$return = patterns_invoke($action, 'form_id');
// If prepare removed the data, dont continue with this action
if (!$action || !$return) {
return $result;
}
if (is_string($return)) {
$form_ids = array($return);
}
else if ($return) {
$form_ids = $return;
}
$action_descriptions = patterns_invoke($action, 'actions');
$action_location = patterns_locate_action($place, $actions_map);
$index = $action_location['key'] + 1;
$pattern_title = $action_location['title'];
$pattern_file = $action_location['file'];
// Build the action
foreach($form_ids as $form_id) {
$clone = $action;
$action_description = isset($action_descriptions[$form_id]) ? $action_descriptions[$form_id] : t('System: Execute form');
$result['action_descriptions'][$place][] = $action_description;
// If tokens are enabled, apply tokens to the action values
// before processing
if (module_exists('token')) {
_patterns_recurse_tokens($clone, $identifiers);
//array_walk($clone, '_patterns_replace_tokens', $identifiers);
}
$error = patterns_invoke($clone, 'validate', $form_id);
if ($message = patterns_error_get_last('validate', $index, $action_description, $pattern_title, $pattern_file)) {
$result['error_message'] = $message;
$result['success'] = FALSE;
return $result;
}
if ($error) {
$message = t('An error occured while validating action #%num (%action) in %title pattern', array('%num' => $index, '%action' => $action_description, '%title' => $pattern_title));
$result['error_message'] = $message .'
'. $error;
$result['success'] = FALSE;
return $result;
}
// Get the form data for the action. This can either just be the form values,
// or it can be the full form_state object
$form_obj = patterns_invoke($clone, 'build', $form_id);
if ($message = patterns_error_get_last('build', $index, $action_description, $pattern_title, $pattern_file)) {
$result['error_message'] = $message;
$result['success'] = FALSE;
return $result;
}
// Dont execute the action if a string was returned, indicating the pattern component
// most likely handled the action on its own and this is the message to display.
if (is_string($form_obj)) {
drupal_set_message($form_obj);
}
else {
// We check for the 'storage' and 'submitted' values in the object to see
// if it is a form_state instead of form_values. There could be a better way
// to do this.
if (array_key_exists('submitted', (array)$form_obj) && array_key_exists('storage', (array)$form_obj)) {
$action_state = $form_obj;
}
else {
$action_state = array(
'storage' => null,
'submitted' => false,
'values' => $form_obj
);
}
// Get any extra parameters required for the action
$params = patterns_invoke($clone, 'params', $form_id, $action_state);
if ($message = patterns_error_get_last('params', $index, $action_description, $pattern_title, $pattern_file)) {
$result['error_message'] = $message;
$result['success'] = FALSE;
return $result;
}
// A single, simple value can be returned as a parameter, which is then
// put into an array here.
if (isset($params) && !is_array($params)) {
$params = array($params);
}
// Execute action
patterns_execute_action($form_id, $action_state, $params);
if ($message = patterns_error_get_last('execute', $index, $action_description, $pattern_title, $pattern_file)) {
$result['error_message'] = $message;
$result['success'] = FALSE;
return $result;
}
if ($errors = form_get_errors()) {
$result['error_message'] = t('Above error(s) occured while executing action #%num (%action) in %title pattern. Error location(s) are: %errors', array('%num' => $index, '%action' => $action_description, '%title' => $pattern_title, '%errors' => str_replace('][', '->', implode(', ', array_keys($errors)))));
$result['success'] = FALSE;
return $result;
}
// Let a component cleanup after each action
patterns_invoke($clone, 'cleanup', $form_id, $action_state);
if ($message = patterns_error_get_last('cleanup', $index, $action_description, $pattern_title, $pattern_file)) {
$result['error_message'] = $message;
$result['success'] = FALSE;
return $result;
}
}
// Clear the cache in case it causes problems
cache_clear_all();
// Rebuild the menu
// TODO Should this go at the end only when a pattern successfully runs?
variable_set('menu_rebuild_needed', true);
}
// Get any primary identifiers from the action for further actions to take advantage of
$id = null;
$id = patterns_invoke($clone, 'identifier', $form_id, $action_state);
if (isset($id)) {
$index = isset($clone['action_label']) ? $clone['action_label'] : $place+1;
$identifiers[$index] = $id;
}
patterns_restore_error_handler();
return $result;
}
/**
* Execute an action
*/
function patterns_execute_action($form_id, &$form_state, $params) {
// Make sure we always have a clear cache for everything
// Beware - this direct database access needs to be db-prefix-safe!
global $db_prefix;
$result = db_query('SHOW TABLES LIKE "{cache}_%"');
while ($table = db_fetch_array($result)) {
// Remove the db prefix if any. cache_clear_all() will put it back again.
$table = substr(current($table), strlen($db_prefix));
cache_clear_all(null, $table);
}
$args = array($form_id, &$form_state);
if (is_array($params)) {
$args = array_merge($args, $params);
}
patterns_executing(true);
// If we are in batch mode, trick the form api to think
// otherwise to avoid potential problems
$batch =& batch_get();
$batch_clone = $batch;
$batch = null;
//$form = call_user_func_array('drupal_retrieve_form', $args);
//$form['#post'] = $values;
//$return = drupal_process_form($form_id, $form);
//dpm($args);
// drupal_execute fails to keep $form_state in-sync through the
// whole FAPI process. Issue http://drupal.org/node/346244
//$return = call_user_func_array('drupal_execute', $args);
// Fix some parts of the #post values based on the original form
patterns_sync_form_values($args);
// Copy of drupal_execute until above issue is fixed
$form = call_user_func_array('drupal_retrieve_form', $args);
$form['#post'] = $form_state['values'];
drupal_prepare_form($form_id, $form, $form_state);
// If you call drupal_validate_form() on the same form more
// than once per page request, validation is not performed
// on any but the first call.
// see issue: http://drupal.org/node/260934
// drupal_process_form($form_id, $form, $form_state);
// Until above issue is fixed we use our own implementation
// of drupal_process_form() and drupal_validate_form().
_patterns_process_form($form_id, $form, $form_state);
patterns_executing(false);
$batch = $batch_clone;
return $return;
}
function patterns_executing($b = null) {
static $executing = false;
if (is_bool($b)) {
$executing = $b;
}
return $executing;
}
function patterns_rearrange_data($pattern) {
foreach($pattern as $key => $value) {
if (is_string($key)) {
unset($pattern[$key]);
}
else {
if ($value['tag'] == 'actions') {
$pattern[$key] = patterns_rearrange_data($value);
$pattern[$key]['tag'] = 'actions';
}
else {
$pattern[$key] = _patterns_rearrange_data($value);
}
}
}
return $pattern;
}
/**
* Return an array with detailed information about the pattern
*/
function patterns_get_pattern_details($pattern, $recursive = FALSE, &$pids = array()) {
// prevent infinite recursion
if (in_array($pattern->pid, $pids)) return array();
$pids[] = $pattern->pid;
$actions = !empty($pattern->pattern['actions']) ? $pattern->pattern['actions'] : array();
$modules = !empty($pattern->pattern['modules']) ? $pattern->pattern['modules'] : array();
$patterns[$pattern->pid] = (array)$pattern;
$patterns[$pattern->pid] = array_merge($patterns[$pattern->pid], $patterns[$pattern->pid]['pattern']['info']);
unset($patterns[$pattern->pid]['pattern']);
if ($recursive) {
$result = array('modules' => $modules, 'info' => $patterns);
foreach($actions as $key => $action) {
if ($action['tag'] == 'pattern') {
// determine pattern name
if (!empty($action['value'])) {
$name = $action['value'];
}
elseif (!empty($action['name'])) {
$name = $action['name'];
}
if (!$p = patterns_get_pattern($name)) {
// just give a warning and try to continue
drupal_set_message(t('Action #%key in %file: Pattern %pattern not found.
Pattern execution will try to continue without it.', array('%key' => $key+1, '%file' => $pattern->title, '%pattern' => $name)), 'warning');
continue;
}
$a = patterns_get_pattern_details($p, TRUE, $pids);
// array_merge doesn't preserve numeric array keys
// so we handle 'info' separately
$info = $result['info'];
$result = array_merge_recursive($result, $a);
$result['info'] = $info + $a['info'];
}
else {
$result['actions'][] = $action;
$result['actions_map'][] = array(
'pid' => $pattern->pid,
'index' => $key,
);
}
}
$result['modules'] = array_merge(array_unique($result['modules']));
return $result;
}
return array('actions' => $actions, 'modules' => $modules, 'info' => $patterns);
}
//function patterns_process_modules($modules, $op = 'enable') {
// // Enable at the beginning of the pattern. Disable at the end.
// for($i=0;$module=$modules[$i];$i++) {
// if (($op == 'enable' && $module['delete']) || ($op == 'disable' && !$module['delete'])) {
// unset($modules[$i]);
// }
// }
//
// patterns_invoke($empty, 'tag modules');
// $error = patterns_invoke($modules, 'pre-validate');
//
// // Error validating modules
// if ($error) {
// return $error;
// }
//
// patterns_invoke($modules, 'prepare');
//}
function patterns_invoke(&$data, $op, $form_id = null, &$a = null) {
static $tag_modules;
if (!is_array($tag_modules) || $op == 'tag modules') {
// Get a list of tags and their modules
foreach(module_implements('patterns') as $module) {
$tags = module_invoke($module, 'patterns', 'tags');
foreach($tags as $tag => $value) {
if (is_array($value)) {
$tag_modules[$tag] = $module;
}
else {
$tag_modules[$value] = $module;
}
}
}
}
// If you just want the modules list
if ($op == 'tag modules') {
return $tag_modules;
}
$tag = $data['tag'];
unset($data['tag']);
$module = $tag_modules[$tag];
$func = $module .'_patterns';
if (function_exists($func)) {
if ($form_id) {
$return = $func($op, $form_id, $data, $a);
}
else {
$return = $func($op, $tag, $data, $a);
}
}
$data['tag'] = $tag;
return $return;
}
function _patterns_rearrange_data($data, $parent = '') {
$numeric = array();
$count=0;
foreach($data as $key => $value) {
if ($value['value'] == 'false') {
$value['value'] = false;
}
else if ($value['value'] == 'true') {
$value['value'] = true;
}
if (is_numeric($key) && is_array($value) && count($value) == 2 && isset($value['tag']) && isset($value['value'])) {
unset($data[$key]);
if (isset($data[$value['tag']])) {
$numeric[] = $value['tag'];
$data[$count++] = $data[$value['tag']];
$data[$count++] = $value['value'];
unset($data[$value['tag']]);
}
else if (in_array($value['tag'], $numeric)) {
$data[$count++] = $value['value'];
}
else {
$data[$value['tag']] = $value['value'];
}
}
else if (is_numeric($key)) {
$tag = $value['tag'];
unset($value['tag']);
$data[$tag][] = _patterns_rearrange_data($value, $tag);
unset($data[$key]);
}
}
foreach($data as $key => $value) {
if (is_array($value) && count($value) == 1 && $value[0]) {
$data[$key] = $data[$key][0];
}
}
return $data;
}
function patterns_form_alter(&$form, &$form_state, $form_id) {
if (user_access('administer patterns') && variable_get('patterns_form_helper', FALSE)) {
$form['#after_build'][] = 'patterns_form_helper';
}
if (patterns_executing()) {
// Ensure that parent and related dropdowns display all the terms
// including those created during current pattern execution.
// Without this, those terms would be omitted due to the static
// caching within taxonomy_get_tree().
$form_ids = array('taxonomy_form_term');
if (in_array($form_id, $form_ids)) {
$tid = $form['#term']['tid'];
$vid = $form['#vocabulary']['vid'];
$parent = array_keys(taxonomy_get_parents($tid));
$children = _patterns_taxonomy_get_tree($vid, $tid);
// A term can't be the child of itself, nor of its children.
foreach ($children as $child) {
$exclude[] = $child->tid;
}
$exclude[] = $tid;
$form['advanced']['parent'] = _patterns_taxonomy_term_select(t('Parents'), 'parent', $parent, $vid, t('Parent terms') .'.', 1, '<'. t('root') .'>', $exclude);
$form['advanced']['relations'] = _patterns_taxonomy_term_select(t('Related terms'), 'relations', array_keys(taxonomy_get_related($tid)), $vid, NULL, 1, '<'. t('none') .'>', array($tid));
}
// Ensure that parent item dropdown displays all the menu items
// including those created during current pattern execution.
// Without this, those menu items would be omitted due to the
// static caching within menu_tree_all_data().
$form_ids = array('menu_edit_item');
if (in_array($form_id, $form_ids)) {
if (empty($form['menu']['#item'])) {
$item = array('link_title' => '', 'mlid' => 0, 'plid' => 0, 'menu_name' => $form_state['values']['menu']['menu_name'], 'weight' => 0, 'link_path' => '', 'options' => array(), 'module' => 'menu', 'expanded' => 0, 'hidden' => 0, 'has_children' => 0);
}
else {
$item = $form['menu']['#item'];
}
$form['menu']['parent']['#options'] = _patterns_menu_parent_options(menu_get_menus(), $item);
}
// Ensure that taxonomy dropdowns on node edit form display all the terms
// including those created during current pattern execution.
if (!empty($form['taxonomy']) && isset($form['type']) && isset($form['#node']) && $form['type']['#value'] .'_node_form' == $form_id) {
foreach ($form['taxonomy'] as $vid => $v) {
if (!is_numeric($vid)) continue;
$form['taxonomy'][$vid] = _patterns_taxonomy_form($vid, $form['taxonomy'][$vid]['#default_value'], $form['taxonomy'][$vid]['#description']);
}
}
}
}
function patterns_form_helper($form, $form_state) {
static $form_id;
if (!$form_id && $form_state['submitted'] && !form_get_errors()) {
$form_id = $form_state['values']['form_id'];
$_SESSION['patterns_form_helper'] = array('form_id' => $form_id, 'form_values' => $form_state['values']);
}
return $form;
}
function patterns_exit($destination = null) {
$batch =& batch_get();
if (variable_get('patterns_form_helper', FALSE) && $_SESSION['patterns_form_helper'] && !$destination && empty($batch)) {
if (module_exists('devel')) {
//dpm($_SESSION['patterns_form_helper']);
kprint_r($_SESSION['patterns_form_helper']);
}
else {
print theme('patterns_form_helper', $_SESSION['patterns_form_helper']['form_id'], $_SESSION['patterns_form_helper']['form_values']);
}
}
}
/**
* Implementation of hook_token_values()
*
* @If these get implementated directly into token.module, this should be removed
*/
function patterns_token_values($type, $object = NULL, $options = array()) {
if ($type == 'global') {
$path = conf_path();
$tokens['confpath'] = $path;
return $tokens;
}
}
/**
* Function callback
*/
function _patterns_modify_value(&$form) {
foreach($form as $key => $value) {
if (is_array($value) && isset($value['#type']) && $value['#type'] == 'value') {
$form[$key]['#default_value'] = $value['#value'];
unset($form[$key]['#value']);
}
else if (is_array($value)) {
_patterns_modify_value($form[$key]);
}
}
}
/**
* Recurse an array and replace with tokens
* @ This is used instead of array_walk_recursive because
* of some strange issues with token_get_values failing.
*/
function _patterns_recurse_tokens(&$object, $identifiers) {
foreach($object as $key => $value) {
if (is_array($value)) {
_patterns_recurse_tokens($object[$key], $identifiers);
}
else if (is_scalar($value)) {
$old_key = $key;
_patterns_replace_tokens($object[$key], $key, $identifiers);
// The key was changed, change it
if ($old_key != $key) {
$keys = array_keys($object);
$keys[array_search($old_key, $keys)] = $key;
$object = array_combine($keys, array_values($object));
}
}
}
}
/**
* Array walk callback to replace tokens inside form values
*/
function _patterns_replace_tokens(&$a, &$b, $identifiers = array()) {
static $count = 0;
// Replace IDs with identifiers from the current executing pattern
if (preg_match('/@([a-zA-Z0-9_]+)@/', $a, $match)) {
$a = str_replace($match[0], $identifiers[$match[1]], $a);
}
if (preg_match('/__([a-zA-Z0-9_]+)__/', $b, $match)) {
$b = str_replace($match[0], $identifiers[$match[1]], $a);
}
// Replace tokens
$a = token_replace($a, 'global', NULL, '@', '@');
$b = token_replace($b, 'global', NULL, '__', '__');
}
/**
* Check if a .htaccess file exists to prevent downloads of pattern files
*/
function _patterns_check_file_dir() {
return false;
$path = file_create_path(variable_get('patterns_save_xml', 'patterns'));
if (!is_file($path .'/.htaccess')) {
$content = '# Prevent downloading site patterns
Order allow,deny
';
file_save_data($content, $path .'/.htaccess');
}
}
function theme_patterns_form_helper_menu($forms) {
$output = '