832 lines
23 KiB
Plaintext
832 lines
23 KiB
Plaintext
<?php
|
|
/**
|
|
* @file
|
|
* Code for the Farm Log feature.
|
|
*/
|
|
|
|
// Include Features code.
|
|
include_once 'farm_log.features.inc';
|
|
|
|
/**
|
|
* Implements hook_entity_view().
|
|
*/
|
|
function farm_log_entity_view($entity, $type, $view_mode, $langcode) {
|
|
|
|
// If the entity is not a log, bail.
|
|
if ($type != 'log') {
|
|
return;
|
|
}
|
|
|
|
// Add the log type.
|
|
$log_types = log_type_get_names();
|
|
if (!empty($log_types[$entity->type])) {
|
|
$entity->content['type'] = array(
|
|
'#markup' => '<div><strong>Log type:</strong> ' . $log_types[$entity->type] . '</div>',
|
|
'#weight' => -101,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements hook_form_alter().
|
|
*/
|
|
function farm_log_form_alter(&$form, &$form_state, $form_id) {
|
|
|
|
// If this is a log form, attempt to prepopulate name and reference fields.
|
|
if ($form_id == 'log_form') {
|
|
farm_log_prepopulate_log_form_name($form);
|
|
farm_log_prepopulate_log_form_references($form);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements hook_entity_presave().
|
|
*/
|
|
function farm_log_entity_presave($entity, $type) {
|
|
|
|
// When a log entity is being saved, populate the geometry field from areas.
|
|
if ($type == 'log') {
|
|
farm_log_populate_geometry($entity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements hook_action_info().
|
|
*/
|
|
function farm_log_action_info() {
|
|
return array(
|
|
'farm_log_asset_action' => array(
|
|
'type' => 'farm_asset',
|
|
'label' => t('Add log'),
|
|
'configurable' => TRUE,
|
|
'triggers' => array('any'),
|
|
'aggregate' => TRUE,
|
|
),
|
|
'farm_log_assign_action' => array(
|
|
'type' => 'log',
|
|
'label' => t('Assign'),
|
|
'configurable' => TRUE,
|
|
'triggers' => array('any'),
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Configuration form for farm_log_asset_action.
|
|
*
|
|
* @param array $context
|
|
* The context passed into the action form function.
|
|
* @param array $form_state
|
|
* The form state passed into the action form function.
|
|
*
|
|
* @return array
|
|
* Returns a form array.
|
|
*/
|
|
function farm_log_asset_action_form(array $context, array $form_state) {
|
|
|
|
// Load a list of all available log types.
|
|
$log_types = log_types();
|
|
|
|
// Get information about field instances on logs.
|
|
$field_instances = field_info_instances('log');
|
|
|
|
// Build a list of log type options.
|
|
$log_type_options = array();
|
|
foreach ($log_types as $log_type => $info) {
|
|
|
|
// If this log type does not have field_farm_asset, skip it.
|
|
if (empty($field_instances[$log_type]['field_farm_asset'])) {
|
|
continue;
|
|
}
|
|
|
|
// Add the log type to the list of options.
|
|
$log_type_options[$log_type] = $info->label;
|
|
}
|
|
|
|
// Log type select list.
|
|
$form['log_type'] = array(
|
|
'#type' => 'select',
|
|
'#title' => t('Log type'),
|
|
'#description' => t('What type of log would you like to create?'),
|
|
'#options' => $log_type_options,
|
|
'#required' => TRUE,
|
|
);
|
|
|
|
// Return the form.
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* Submit handler for farm_log_asset_action configuration form.
|
|
*
|
|
* @param array $form
|
|
* The form array.
|
|
* @param array $form_state
|
|
* The form state array.
|
|
*
|
|
* @return array
|
|
* Returns an array that will end up in the action's context.
|
|
*/
|
|
function farm_log_asset_action_submit(array $form, array $form_state) {
|
|
|
|
// Start to build the context array.
|
|
$context = array();
|
|
|
|
// Add the log type to the context.
|
|
$context['log_type'] = $form_state['values']['log_type'];
|
|
|
|
// Return the context array.
|
|
return $context;
|
|
}
|
|
|
|
/**
|
|
* Action function for farm_log_asset_action.
|
|
*
|
|
* Sends the user to a new log form with the selected assets referenced.
|
|
*
|
|
* @param array $assets
|
|
* An array of asset entities.
|
|
* @param array $context
|
|
* Array with parameters for this action.
|
|
*/
|
|
function farm_log_asset_action(array $assets, $context = array()) {
|
|
|
|
// Redirect to the log creation form for the selected type, with the asset
|
|
// IDs passed as query parameters.
|
|
$options = array(
|
|
'query' => array(
|
|
'farm_asset' => array_keys($assets),
|
|
),
|
|
);
|
|
drupal_goto('log/add/' . $context['log_type'], $options);
|
|
}
|
|
|
|
/**
|
|
* Log assign action configuration form.
|
|
*
|
|
* @param array $context
|
|
* The context passed into the action form function.
|
|
* @param array $form_state
|
|
* The form state passed into the action form function.
|
|
*
|
|
* @return array
|
|
* Returns a form array.
|
|
*/
|
|
function farm_log_assign_action_form(array $context, array $form_state) {
|
|
|
|
// Generate a list of users. Only include users with farm roles.
|
|
$user_options = array();
|
|
$roles = farm_access_roles();
|
|
$query = db_query('SELECT u.uid, u.name FROM {users} u LEFT JOIN {users_roles} ur ON u.uid = ur.uid LEFT JOIN {role} r ON ur.rid = r.rid WHERE r.name IN (:roles)', array(':roles' => $roles));
|
|
$records = $query->fetchAll();
|
|
foreach ($records as $record) {
|
|
$user_options[$record->uid] = $record->name;
|
|
}
|
|
|
|
// Display a multi-select list.
|
|
$form['users'] = array(
|
|
'#type' => 'select',
|
|
'#title' => t('Assign log(s) to'),
|
|
'#description' => t('Select people to assign these logs to.'),
|
|
'#options' => $user_options,
|
|
'#multiple' => TRUE,
|
|
);
|
|
|
|
// Add a checkbox for appending the users instead of overwriting them.
|
|
$form['operation'] = array(
|
|
'#type' => 'radios',
|
|
'#title' => t('Append or Replace'),
|
|
'#description' => t('Select "Append" if you want to add users to the logs, but keep existing assignments. Select "Replace" if you want to replace existing assignments with the ones specified above.'),
|
|
'#options' => array(
|
|
'append' => t('Append'),
|
|
'replace' => t('Replace'),
|
|
),
|
|
'#default_value' => 'append',
|
|
);
|
|
|
|
// Return the form.
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* Log assign action configuration form submit.
|
|
*
|
|
* @param array $form
|
|
* The form array.
|
|
* @param array $form_state
|
|
* The form state array.
|
|
*
|
|
* @return array
|
|
* Returns an array that will end up in the action's context.
|
|
*/
|
|
function farm_log_assign_action_submit(array $form, array $form_state) {
|
|
return array(
|
|
'users' => $form_state['values']['users'],
|
|
'operation' => $form_state['values']['operation'],
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Action function for farm_log_assign_action.
|
|
*
|
|
* Assigns a log to one or more people.
|
|
*
|
|
* @param Log $log
|
|
* The log entity object.
|
|
* @param array $context
|
|
* Array with parameters for this action.
|
|
*/
|
|
function farm_log_assign_action(Log $log, $context = array()) {
|
|
|
|
// If the operation is invalid, bail.
|
|
if (!in_array($context['operation'], array('append', 'replace'))) {
|
|
drupal_set_message('Invalid operation.');
|
|
return;
|
|
}
|
|
|
|
// If the operation is 'append', and there are no users, bail.
|
|
if ($context['operation'] == 'append' && empty($context['users'])) {
|
|
return;
|
|
}
|
|
|
|
// Create an entity wrapper for the log.
|
|
$log_wrapper = entity_metadata_wrapper('log', $log);
|
|
|
|
// If the owner field doesn't exist, bail.
|
|
if (!isset($log_wrapper->field_farm_log_owner)) {
|
|
return;
|
|
}
|
|
|
|
// Keep track of users that are already assigned.
|
|
$existing_users = array();
|
|
|
|
// If we are appending, load existing owner IDs.
|
|
if ($context['operation'] == 'append' && !empty($log_wrapper->field_farm_log_owner)) {
|
|
foreach ($log_wrapper->field_farm_log_owner->getIterator() as $delta => $user_wrapper) {
|
|
$existing_users[] = $user_wrapper->uid->value();
|
|
}
|
|
}
|
|
|
|
// Or, if we are replacing, clear out the existing owner IDs.
|
|
elseif ($context['operation'] == 'replace') {
|
|
$log_wrapper->field_farm_log_owner = array();
|
|
}
|
|
|
|
// Assume that we are not going to save the log.
|
|
$save = FALSE;
|
|
|
|
// Iterate through the users.
|
|
foreach ($context['users'] as $uid) {
|
|
|
|
// If the ID is empty, skip it.
|
|
if (empty($uid)) {
|
|
continue;
|
|
}
|
|
|
|
// Load the user.
|
|
$user = user_load($uid);
|
|
|
|
// if the user didn't load, skip it.
|
|
if (empty($user)) {
|
|
continue;
|
|
}
|
|
|
|
// If the user is already referenced in the log, skip it.
|
|
if (in_array($user->uid, $existing_users)) {
|
|
continue;
|
|
}
|
|
|
|
// Add the user ID to the array of existing users so we don't accidentally
|
|
// add the same one more than once. Shouldn't happen, but be defensive.
|
|
$existing_users[] = $user->uid;
|
|
|
|
// Add the user to the log's owner field.
|
|
$log_wrapper->field_farm_log_owner[] = $user;
|
|
|
|
// We will save the log.
|
|
$save = TRUE;
|
|
}
|
|
|
|
// If we should save the log, then save it.
|
|
if ($save) {
|
|
$log_wrapper->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function for creating log categories. Terms will only be added if
|
|
* they don't already exist.
|
|
*
|
|
* @param array $categories
|
|
* An array of strings that will be added as terms to the Farm Log Categories
|
|
* vocabulary.
|
|
*/
|
|
function farm_log_categories_create($categories) {
|
|
|
|
// If the categories is not an array, bail.
|
|
if (!is_array($categories)) {
|
|
return;
|
|
}
|
|
|
|
// Define the vocabulary machine name.
|
|
$vocabulary_machine_name = 'farm_log_categories';
|
|
|
|
// Load the vocabulary.
|
|
$vocabulary = taxonomy_vocabulary_machine_name_load($vocabulary_machine_name);
|
|
|
|
// If the vocabulary doesn't exist, bail.
|
|
if (empty($vocabulary->vid)) {
|
|
return;
|
|
}
|
|
|
|
// Iterate through the categories.
|
|
foreach ($categories as $category) {
|
|
|
|
// First, check to see if the term already exists. If it does, skip it.
|
|
$terms = taxonomy_get_term_by_name($category, $vocabulary_machine_name);
|
|
if (!empty($terms)) {
|
|
continue;
|
|
}
|
|
|
|
// Translate the category name.
|
|
$term_name = t($category);
|
|
|
|
// Create the new term.
|
|
$term = new stdClass();
|
|
$term->name = $term_name;
|
|
$term->vid = $vocabulary->vid;
|
|
taxonomy_term_save($term);
|
|
}
|
|
|
|
// Always reset the categories to alphabetical order.
|
|
/**
|
|
* @see taxonomy_vocabulary_confirm_reset_alphabetical_submit()
|
|
*/
|
|
db_update('taxonomy_term_data')
|
|
->fields(array('weight' => 0))
|
|
->condition('vid', $vocabulary->vid)
|
|
->execute();
|
|
}
|
|
|
|
/**
|
|
* Create log categories on behalf of all modules that provide them.
|
|
*/
|
|
function farm_log_categories_create_all() {
|
|
$categories = module_invoke_all('farm_log_categories');
|
|
if (!empty($categories)) {
|
|
farm_log_categories_create($categories);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function for populating a log's geometry from an area reference field.
|
|
*
|
|
* @param Entity $entity
|
|
* The entity to act upon.
|
|
*
|
|
* @see farm_log_entity_movement_presave().
|
|
*/
|
|
function farm_log_populate_geometry($entity) {
|
|
|
|
// Define the area field name.
|
|
$area_field = 'field_farm_area';
|
|
|
|
// If the log doesn't have an area reference field, bail.
|
|
if (!isset($entity->{$area_field})) {
|
|
return;
|
|
}
|
|
|
|
// If a geometry is already defined, bail.
|
|
if (!empty($entity->field_farm_geofield[LANGUAGE_NONE][0]['geom'])) {
|
|
return;
|
|
}
|
|
|
|
// Load the area(s) referenced by the area reference field.
|
|
$area_ids = array();
|
|
if (!empty($entity->{$area_field}[LANGUAGE_NONE])) {
|
|
foreach ($entity->{$area_field}[LANGUAGE_NONE] as $area_reference) {
|
|
if (!empty($area_reference['tid'])) {
|
|
$area_ids[] = $area_reference['tid'];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract geometries from the areas.
|
|
$geoms = farm_area_extract_geoms($area_ids);
|
|
|
|
// Populate the geofield.
|
|
farm_map_geofield_populate($entity, $geoms);
|
|
}
|
|
|
|
/**
|
|
* Helper function for populating the name field in log forms.
|
|
*
|
|
* @param array $form
|
|
* The form array to modify, passed by reference.
|
|
*/
|
|
function farm_log_prepopulate_log_form_name(&$form) {
|
|
|
|
// If the GET parameter isn't set, bail.
|
|
$params = drupal_get_query_parameters();
|
|
if (empty($params['name'])) {
|
|
return;
|
|
}
|
|
|
|
// If the log form name field already has a default value, bail.
|
|
if (!empty($form['name']['#default_value'])) {
|
|
return;
|
|
}
|
|
|
|
// Set the name in the form.
|
|
$form['name']['#default_value'] = $params['name'];
|
|
}
|
|
|
|
/**
|
|
* Implements hook_farm_log_prepopulate_reference_fields().
|
|
*/
|
|
function farm_log_farm_log_prepopulate_reference_fields($log_type) {
|
|
|
|
// Define the fields that will be prepopulated in log forms.
|
|
return array(
|
|
'field_farm_asset' => array(
|
|
'entity_type' => 'farm_asset',
|
|
'url_param' => 'farm_asset',
|
|
),
|
|
'field_farm_area' => array(
|
|
'entity_type' => 'taxonomy_term',
|
|
'url_param' => 'farm_area',
|
|
),
|
|
'field_farm_log_category' => array(
|
|
'entity_type' => 'taxonomy_term',
|
|
'lookup' => TRUE,
|
|
'vocabulary' => 'farm_log_categories',
|
|
'url_param' => 'category',
|
|
),
|
|
'field_farm_log_owner' => array(
|
|
'entity_type' => 'user',
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Helper function for populating entity reference fields in log forms.
|
|
*
|
|
* @param array $form
|
|
* The form array to modify, passed by reference.
|
|
*/
|
|
function farm_log_prepopulate_log_form_references(&$form) {
|
|
|
|
// Get the log type from the form. Bail if none.
|
|
if (empty($form['#bundle'])) {
|
|
return;
|
|
}
|
|
$log_type = $form['#bundle'];
|
|
|
|
// Ask modules for information about fields that should be prepopulated for
|
|
// this log type.
|
|
$fields = module_invoke_all('farm_log_prepopulate_reference_fields', $log_type);
|
|
|
|
// Allow modules to alter the field information.
|
|
drupal_alter('farm_log_prepopulate_reference_fields', $fields, $log_type);
|
|
|
|
// Populate the fields.
|
|
foreach ($fields as $field => $info) {
|
|
|
|
// Start with an empty array of IDs.
|
|
$ids = array();
|
|
|
|
// If the field does not exist on the log, skip it.
|
|
if (!isset($form[$field])) {
|
|
continue;
|
|
}
|
|
|
|
// If a URL param is available, get a list of entity IDs from it.
|
|
if (!empty($info['url_param'])) {
|
|
|
|
// Get query parameters.
|
|
$params = drupal_get_query_parameters();
|
|
|
|
// If the URL param is set, pull the IDs out.
|
|
if (!empty($params[$info['url_param']])) {
|
|
$ids = $params[$info['url_param']];
|
|
}
|
|
}
|
|
|
|
// Or, if the entity type is 'user', load the ID from the current user.
|
|
elseif ($info['entity_type'] == 'user') {
|
|
global $user;
|
|
if (!empty($user->uid)) {
|
|
$ids[] = $user->uid;
|
|
}
|
|
}
|
|
|
|
// Ensure that the IDs are an array.
|
|
if (!is_array($ids)) {
|
|
$ids = array($ids);
|
|
}
|
|
|
|
// Allow modules to add log categories.
|
|
if ($field == 'field_farm_log_category' && !empty($form['#entity'])) {
|
|
$categories = module_invoke_all('farm_log_categories_populate', $form['#entity']);
|
|
if (!empty($categories)) {
|
|
foreach ($categories as $category) {
|
|
if (is_string($category)) {
|
|
$ids[] = t($category);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there are no IDs, skip.
|
|
if (empty($ids)) {
|
|
continue;
|
|
}
|
|
|
|
// Look up taxonomy term IDs, if necessary.
|
|
if ($info['entity_type'] == 'taxonomy_term' && !empty($info['lookup']) && !empty($info['vocabulary'])) {
|
|
$term_names = $ids;
|
|
$ids = array();
|
|
foreach ($term_names as $name) {
|
|
$terms = taxonomy_get_term_by_name($name, $info['vocabulary']);
|
|
$term = reset($terms);
|
|
if (!empty($term->tid)) {
|
|
$ids[] = $term->tid;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prepopulate with the farm_fields helper function.
|
|
farm_fields_prepopulate_entityreference($form, $info['entity_type'], $field, $ids);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function for building a select query of logs related to assets.
|
|
*
|
|
* This builds on top of the more general farm_log_query() function.
|
|
*
|
|
* @see farm_log_query()
|
|
*
|
|
* @param int|string $asset_id
|
|
* The asset id to search for. This can either be a specific id, or a field
|
|
* alias string from another query (ie: 'mytable.assetid'). For an example
|
|
* of field alias string usage, see the Views field handler code in
|
|
* farm_movement_handler_relationship_location::query(). If this is omitted,
|
|
* the asset reference table will still be joined in, but no further
|
|
* filtering will be done.
|
|
* @param int $time
|
|
* Unix timestamp limiter. Only logs before this time will be included.
|
|
* Defaults to the current time. Set to 0 to load the absolute last.
|
|
* @param bool $done
|
|
* Whether or not to only show logs that are marked as "done". Defaults to
|
|
* TRUE.
|
|
* @param bool $single
|
|
* Whether or not to limit the query to a single result. Defaults to TRUE.
|
|
*
|
|
* @return \SelectQuery
|
|
* Returns a SelectQuery object.
|
|
*/
|
|
function farm_log_asset_query($asset_id = NULL, $time = REQUEST_TIME, $done = TRUE, $single = TRUE) {
|
|
|
|
/**
|
|
* Please read the comments in farm_log_query() to understand how this works,
|
|
* and to be aware of the limitations and responsibilities we have in this
|
|
* function with regard to sanitizing query inputs.
|
|
*/
|
|
|
|
// Start with a query from the farm_log_query() helper function.
|
|
$query = farm_log_query($time, $done, $single);
|
|
|
|
// Ensure $asset_id is valid, because it will be used directly in the query
|
|
// string. This is defensive code. See note about farm_log_query() above.
|
|
if (!is_numeric($asset_id) || $asset_id < 0) {
|
|
$asset_id = db_escape_field($asset_id);
|
|
}
|
|
|
|
// Join in asset reference field. Use an inner join to exclude logs that do
|
|
// not have any asset references.
|
|
$query->innerJoin('field_data_field_farm_asset', 'ss_fdffa', "ss_fdffa.entity_type = 'log' AND ss_fdffa.entity_id = ss_log.id AND ss_fdffa.deleted = 0");
|
|
|
|
// If an asset ID is specified, only include logs that reference it.
|
|
if (!empty($asset_id)) {
|
|
$query->where('ss_fdffa.field_farm_asset_target_id = ' . $asset_id);
|
|
}
|
|
|
|
// Return the query object.
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Helper function for building a select query of logs.
|
|
*
|
|
* This function is used by other modules to build queries and Views handlers
|
|
* that need to find the most recent log in a specific context.
|
|
*
|
|
* Modules can use this to generate a base query, and then add their own
|
|
* modifications on top of that.
|
|
*
|
|
* @param int $time
|
|
* Unix timestamp limiter. Only logs before this time will be included.
|
|
* Defaults to the current time. Set to 0 to load the absolute last.
|
|
* @param bool $done
|
|
* Whether or not to only show logs that are marked as "done". Defaults to
|
|
* TRUE.
|
|
* @param bool $single
|
|
* Whether or not to limit the query to a single result. Defaults to TRUE.
|
|
*
|
|
* @return \SelectQuery
|
|
* Returns a SelectQuery object.
|
|
*/
|
|
function farm_log_query($time = REQUEST_TIME, $done = TRUE, $single = TRUE) {
|
|
|
|
/**
|
|
* This query may be used as a sub-query join in a Views handler via the
|
|
* views_join_subquery class (for an example see:
|
|
* farm_movement_handler_relationship_location). When a sub-query is added
|
|
* via views_join_subquery, it is not possible to use query arguments in the
|
|
* sub-query itself. So we cannot use the query::condition() method, or any
|
|
* other methods that take query arguments separately and perform sanitation
|
|
* on them. Thus, it is the responsibility of this function to sanitize any
|
|
* inputs and use them directly in the SQL.
|
|
*
|
|
* We use the "ss_" prefix on aliases to avoid potential name conflicts when
|
|
* this query is used as a sub-select inside another query.
|
|
*/
|
|
|
|
// Ensure $time is valid, because it may be used directly in the query
|
|
// string. This is defensive code. See note about views_join_subquery above.
|
|
if (!is_numeric($time) || $time < 0) {
|
|
$time = REQUEST_TIME;
|
|
}
|
|
|
|
// Build a query to find a log that references an asset.
|
|
$query = db_select('log', 'ss_log');
|
|
|
|
// If $time is not zero, limit to only logs before it. This allows the
|
|
// absolute last log to be found by setting $time to zero.
|
|
if ($time !== 0) {
|
|
$query->where('ss_log.timestamp <= ' . $time);
|
|
}
|
|
|
|
// If only "done" movement logs should be included, add a filter.
|
|
if ($done) {
|
|
$query->where('ss_log.done = 1');
|
|
}
|
|
|
|
// Order by timestamp and then log id, descending.
|
|
$query->orderBy('ss_log.timestamp', 'DESC');
|
|
$query->orderBy('ss_log.id', 'DESC');
|
|
|
|
// Limit the query to a single result (the first one), if desired.
|
|
if (!empty($single)) {
|
|
$query->range(0, 1);
|
|
}
|
|
|
|
// Return the query object.
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Helper function for creating a farm log.
|
|
*
|
|
* @param string $type
|
|
* The log type machine name.
|
|
* @param string $name
|
|
* Optionally specify a name for the new log.
|
|
* @param int $timestamp
|
|
* The timestamp of the log (defaults to REQUEST_TIME).
|
|
* @param bool $done
|
|
* Boolean indicating whether or not the log is done.
|
|
* @param array $assets
|
|
* An array of assets to reference in the log.
|
|
* @param string $notes
|
|
* Notes to add to the log.
|
|
* @param array $categories
|
|
* An array of categories to add to the log.
|
|
*
|
|
* @return \Log
|
|
* Returns a saved log entity.
|
|
*/
|
|
function farm_log_create($type, $name = '', $timestamp = REQUEST_TIME, $done = TRUE, $assets = array(), $notes = '', $categories = array()) {
|
|
|
|
// Create a new log entity.
|
|
$log = entity_create('log', array('type' => $type));
|
|
|
|
// If a log name is specified, set it.
|
|
if (!empty($name)) {
|
|
$log->name = $name;
|
|
}
|
|
|
|
// Set the timestamp.
|
|
$log->timestamp = $timestamp;
|
|
|
|
// Set the log's done status.
|
|
if (!empty($done)) {
|
|
$log->done = TRUE;
|
|
}
|
|
else {
|
|
$log->done = FALSE;
|
|
}
|
|
|
|
// Add asset references.
|
|
if (!empty($assets)) {
|
|
foreach ($assets as $asset) {
|
|
if (!empty($asset->id)) {
|
|
$log->field_farm_asset[LANGUAGE_NONE][] = array(
|
|
'target_id' => $asset->id,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the notes.
|
|
if (!empty($notes)) {
|
|
$log->field_farm_notes[LANGUAGE_NONE][0]['value'] = $notes;
|
|
$log->field_farm_notes[LANGUAGE_NONE][0]['format'] = 'farm_format';
|
|
}
|
|
|
|
// Add the categories.
|
|
if (!empty($categories)) {
|
|
foreach ($categories as $category) {
|
|
|
|
// Look up the category taxonomy term.
|
|
$terms = taxonomy_get_term_by_name($category, 'farm_log_categories');
|
|
|
|
// If terms were found, use the first one.
|
|
if (!empty($terms)) {
|
|
$term = reset($terms);
|
|
}
|
|
|
|
// If a term wasn't found, create it.
|
|
else {
|
|
$vocab = taxonomy_vocabulary_machine_name_load('farm_log_categories');
|
|
$term = new stdClass();
|
|
$term->name = check_plain($category);
|
|
$term->vid = $vocab->vid;
|
|
taxonomy_term_save($term);
|
|
}
|
|
|
|
// Add the category to the log.
|
|
$log->field_farm_log_category[LANGUAGE_NONE][] = array(
|
|
'tid' => $term->tid,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Set the log owner to the currently authenticated user.
|
|
global $user;
|
|
$log->field_farm_log_owner[LANGUAGE_NONE][] = array(
|
|
'target_id' => $user->uid,
|
|
);
|
|
|
|
// Save the log.
|
|
log_save($log);
|
|
|
|
// Set a message.
|
|
$label = entity_label('log', $log);
|
|
$uri = entity_uri('log', $log);
|
|
drupal_set_message('Log created: ' . l($label, $uri['path']));
|
|
|
|
// Return the log.
|
|
return $log;
|
|
}
|
|
|
|
/**
|
|
* Helper function for generating a summary of entity labels for use in a
|
|
* log name.
|
|
*
|
|
* @param string $entity_type
|
|
* The entity type.
|
|
* @param Entity|array $entities
|
|
* An entity or array of entities.
|
|
* @param int $cutoff
|
|
* The number of entity labels to include before summarizing the rest.
|
|
* If the number of entities exceeds the cutoff, only the first entity's
|
|
* label will be included, and the rest will be summarized as "(+ X more)".
|
|
* If the number of entities is less than or equal to the cutoff, or if the
|
|
* cutoff is 0, all entity labels will be included.
|
|
*
|
|
* @return string
|
|
* Returns a string summarizing the assets.
|
|
*/
|
|
function farm_log_entity_label_summary($entity_type, $entities, $cutoff = 3) {
|
|
$labels = array();
|
|
if (!is_array($entities)) {
|
|
$entities = array($entities);
|
|
}
|
|
foreach ($entities as $entity) {
|
|
$label = entity_label($entity_type, $entity);
|
|
if (!empty($label)) {
|
|
$labels[] = $label;
|
|
}
|
|
}
|
|
$count = count($labels);
|
|
if ($cutoff == 0 || count($labels) <= $cutoff) {
|
|
$output = implode($labels, ', ');
|
|
}
|
|
else {
|
|
$output = $labels[0] . ' (+' . ($count - 1) . ' ' . t('more') . ')';
|
|
}
|
|
return $output;
|
|
}
|