Club Drupal

 */

function hook_flag_default_flags() {

  $flags = array();

    'entity_type' => 'node',

    'title' => 'Bookmarks',

    'global' => FALSE,

      0 => 'article',

      1 => 'blog',

    ),

    'unflag_denied_text' => '',

    'link_type' => 'toggle',

    'weight' => 0,

      'full' => TRUE,

      'token' => FALSE,

    ),

  return $flags;

}

/**

 * Allow modules to alter a flag when it is initially loaded.

 *

 */

function hook_flag_alter(&$flag) {

      $count = count($flags[$flag->name]);

      if ($count >= 2) {

        // Users may flag only 2 nodes with this flag.

      }

    }

  }

files[] = includes/views/flag_plugin_argument_validate_flaggability.inc

files[] = tests/flag.test

core = "7.x"

project = "flag"

<?php

/**

 */

/**

        'not null' => TRUE,

        'default' => 0,

        'disp-size' => 11,

    ),

    'primary key' => array('flagging_id'),

    'unique keys' => array(

    ),

    'indexes' => array(

      'entity_type_uid_sid' => array('entity_type', 'uid', 'sid'),

      'entity_id_fid' => array('entity_id', 'fid'),

    ),

  );

        'not null' => TRUE,

        'default' => 0,

        'disp-size' => 11,

    ),

    'primary key' => array('fid', 'entity_id'),

    'indexes' => array(

function flag_update_6201() {

  // Remove "content type" from one key, see http://drupal.org/node/612602.

  db_drop_unique_key('flag_content', 'fid_content_type_content_id_uid');

  // Add a count index, see http://drupal.org/node/489610.

  db_add_index('flag_counts', 'count', array('count'));

  db_drop_index('flag_content', 'content_type_uid');

  // Add the column.

  // Re-add the removed keys.

}

/**

    db_drop_unique_key('flag_content', 'content_type_content_id_uid_sid');

  }

}

/**

 * Adds column last_updated to flag_counts table.

 */

function flag_update_6207() {

}

/**

      ),

      'indexes' => array(

        'entity_type_uid_sid' => array('entity_type', 'uid', 'sid'),

        'content_id_fid' => array('content_id', 'fid'),

      ),

    )

        'fid_entity_id_uid_sid' => array('fid', 'entity_id', 'uid', 'sid'),

      ),

      'indexes' => array(

        'entity_id_fid' => array('entity_id', 'fid'),

      ),

    )

      'indexes' => array(

        'fid_entity_type' => array('fid', 'entity_type'),

        'entity_type_content_id' => array('entity_type', 'content_id'),

    )

  );

    }

    // Update show_on_comment and show_on_entity properties to use new view

    if (!empty($flag->show_on_entity) || !empty($flag->show_on_comment)) {

      if ($entity_info = entity_get_info($flag->entity_type)) {

        foreach ($entity_info['view modes'] as $view_mode => $value) {

// @todo: flag_reset_flag():

// - it should delete the flaggings.

// - (it has other issues; see http://drupal.org/node/894992.)

// @todo: Discuss: Note that almost all functions/identifiers dealing with

// flaggings *aren't* prefixed by "flag_". For example:

/**

 * Implements hook_entity_query_alter().

  // Alter only flagging queries with bundle conditions.

  if (isset($conditions['entity_type']) && $conditions['entity_type']['value'] == 'flagging' && isset($conditions['bundle'])) {

    // Make value and operator of the bundle condition accessible

    // in hook_query_TAG_alter.

    $query->addMetaData('flag_name_value', $conditions['bundle']['value']);

  );

  $items[FLAG_ADMIN_PATH . '/manage/%flag'] = array(

    'page callback' => 'drupal_get_form',

    'page arguments' => array('flag_form', FLAG_ADMIN_PATH_START + 1),

    'access callback' => 'user_access',

    'title arguments' => array(FLAG_ADMIN_PATH_START + 1),

  );

  $items[FLAG_ADMIN_PATH . '/manage/%flag/edit'] = array(

    'title' => 'Edit flag',

    'type' => MENU_DEFAULT_LOCAL_TASK,

    'weight' => -10,

    'type' => MENU_CALLBACK,

  );

  $items[FLAG_ADMIN_PATH . '/manage/%flag/update'] = array(

    'title' => 'Update',

    'page callback' => 'flag_update_page',

    'page arguments' => array(FLAG_ADMIN_PATH_START + 1),

    case FLAG_ADMIN_PATH:

      $output = '<p>' . t('This page lists all the <em>flags</em> that are currently defined on this system.') . '</p>';

      return $output;

    case FLAG_ADMIN_PATH . '/add':

      $output = '<p>' . t('Select the type of flag to create. An individual flag can only affect one type of object. This cannot be changed once the flag is created.') . '</p>';

      return $output;

    case FLAG_ADMIN_PATH . '/manage/%/fields':

      // Get the existing link types that provide a flagging form.

      $link_types = flag_get_link_types();

function flag_create_handler($entity_type) {

  $definition = flag_fetch_definition($entity_type);

  if (isset($definition) && class_exists($definition['handler'])) {

  }

  else {

  }

  $handler->entity_type = $entity_type;

  $handler->construct();

        $extra[$flag->entity_type][$bundle_name]['form']['flag'] = array(

          'label' => t('Flags'),

          'description' => t('Checkboxes for toggling flags'),

        );

      }

 * Warning: will not work on entity types that are not fieldable, as this relies

 * on a field module hook.

 *

 */

function flag_field_attach_form($entity_type, $entity, &$form, &$form_state, $langcode) {

  list($id) = entity_extract_ids($entity_type, $entity);

/**

 * Implements hook_field_attach_submit().

 *

 */

function flag_field_attach_submit($entity_type, $entity, $form, &$form_state) {

  // This is invoked for each flag_field_attach_form(), but possibly more than

/**

 * Shared saving routine between flag_field_attach_insert/update().

 *

 */

function flag_field_attach_save($entity_type, $entity) {

  list($id) = entity_extract_ids($entity_type, $entity);

      list($entity_id) = entity_extract_ids($entity_type, $entity);

      if (!$flag->access($entity_id) && (!$flag->is_flagged($entity_id) || !$flag->access($entity_id, 'flag'))) {

        continue;

      }

        'title' => $flag->theme($flag->is_flagged($entity_id) ? 'unflag' : 'flag', $entity_id),

        'html' => TRUE,

      );

    // The pseudofield output.

    if ($flag->show_as_field) {

      $entity->content['flag_' . $flag->name] = array(

      );

    }

  }

  $object = $flag->fetch_entity($entity_id);

  // Generic "all flags" actions.

    if ($aid) {

      actions_do($aid, $object, $context);

    }

  $flag =& $variables['flag'];

  $action = $variables['action'];

  $entity_id = $variables['entity_id'];

  $flag_css_name = str_replace('_', '-', $flag->name);

  // Generate the link URL.

      $variables['message_classes_array'][] = 'flag-' . $variables['status'] . '-message';

      $variables['message_text'] = $flag->get_label($inverse_action . '_message', $entity_id);

      $variables['flag_classes_array'][] = $variables['status'];

      $variables['message_classes_array'][] = 'flag-auto-remove';

    }

  }

      ->countQuery()

      ->execute()

      ->fetchField();

  }

  return $counts[$flag->name][$entity_type];

    $query = db_select('flag', 'f');

    $query->leftJoin('flag_types', 'fn', 'fn.fid = f.fid');

    $result = $query

      ->fields('fn', array('type'))

      ->execute();

    foreach ($result as $row) {

        // Ensure overridden flags are associated with their parent module.

        $flags[$name]->module = $default_flag->module;

        if (isset($default_flag->locked)) {

          $flags[$name]->locked = $default_flag->locked;

          foreach ($default_flag->locked as $property) {

  $default_flags = array();

  $flag_status = variable_get('flag_default_flag_status', array());

  foreach (module_implements('flag_default_flags') as $module) {

    $function = $module . '_flag_default_flags';

    foreach ($function() as $flag_name => $flag_info) {

      // Backward compatibility: old exported default flags have their names

        'name' => $flag_name,

        'module' => $module,

      );

    }

  }

 * @return

 *   If returning a single item's flags (that is, when $entity_id isn't NULL),

 *   an array of the structure

 *

 *   If returning all items' flags, an array of arrays for each flag:

 *   [flag_name] => [entity_id] => Object from above.

 */

function flag_get_user_flags($entity_type, $entity_id = NULL, $uid = NULL, $sid = NULL) {

  $flagged_content = &drupal_static(__FUNCTION__);

    $query->orderBy('timestamp', 'ASC');

  }

  else {

  }

  $result = $query->execute();

  $i = 1;

  }

  module_invoke_all('flag_reset', $flag, $entity_id, $rows);

  // Update the flag_counts table.

  $count_query = db_delete('flag_counts')->condition('fid', $flag->fid);

  if ($entity_id) {

 * @ingroup callbacks

 */

function flag_properties_get_user_sid($entity, array $options, $name, $entity_type, $property_info) {

  return $sid;

}

      '#required' => empty($info['optional']),

      '#multiple' => FALSE,

      '#default_value' => $settings[$name],

    );

    return $form;

  }

      'access callback' => 'flag_rules_integration_access',

    );

  }

  $items['flag_fetch_entity_by_user'] = $items['flag_fetch_node_by_user'];

  return $items;

}

}

/**

 */

function flag_rules_action_fetch_entity_by_user($flag, $entity) {

  $query = db_select('flagging', 'fc')

    ->fields('fc', array('entity_id'))

    ->condition('entity_type', $flag->entity_type)

    ->condition('fid', $flag->fid);

  }

  $result = $query->execute();

  $flagged = $result->fetchCol();

}

/**

 *

 * During a flagging, the current flagging will be included in the count.

 * During an unflagging, the current flagging being removed will not yet have

            'type' => 'flag',

            'label' => t('Flag'),

            'flag_type' => $type,

          ),

          $type => array(

            'type' => $type,

            'type' => 'flag',

            'label' => t('Flag'),

            'flag_type' => $type,

          ),

          $type => array(

            'type' => $type,

}

/**

 */

function flag_rules_condition_threshold_operator_options() {

  return array(

  $count = $flag->get_count($flag->get_entity_id($entity));

  switch ($operator) {

    case '>=': return $count >= $number;

    case '<=': return $count <= $number;

  }

}

        case 'name':

          $replacements[$original] = $sanitize ? check_plain($flag->name) : $flag->name;

          break;

        case 'title':

          $replacements[$original] = $sanitize ? check_plain($flag->get_title()) : $flag->get_title();

          break;

        case 'action':

          $replacements[$original] = $action->action;

          break;

        case 'entity-url':

          $replacements[$original] = $sanitize ? check_url($action->entity_url) : $action->entity_url;

          break;

        case 'entity-title':

          $replacements[$original] = $sanitize ? check_plain($action->entity_title) : $action->entity_title;

          break;

        case 'entity-type':

          $replacements[$original] = $action->entity_type;

          break;

        case 'entity-id':

          $replacements[$original] = $action->entity_id;

          break;

        case 'count':

          $replacements[$original] = $action->count;

          break;

files[] = flag.install

files[] = flag_actions.module

core = "7.x"

project = "flag"

  $fieldset = array(

    '#type' => 'fieldset',

    '#title' => t('Add a new flag action'),

    '#parents' => array('add_action'),

    '#attributes' => array(),

    '#groups' => array('add_action' => array()),

 *   If editing an action, an action ID must be passed in.

 * @param $flag_name

 *   If adding a new action to a flag, a flag name must be specified.

 */

function flag_actions_form($form, &$form_state, $aid = NULL, $flag_name = NULL) {

  // This is a multistep form. Get the callback value if set and continue.

  $form['new'] = array(

    '#type' => 'value',

  );

  if (!isset($callback)) {

    $actions = $flag->get_valid_actions();

    $options = array();

      $options[$key] = $action['label'];

    }

  }

  elseif (!isset($action)) {

    $actions = $flag->get_valid_actions();

    $action->parameters = array();

    $action->event = 'flag';

    $action->threshold = 10;

  }

  // Merge in the standard flag action form.

  $edit = array();

  if (function_exists($action_form)) {

    $edit += $action->parameters;

  }

  // Add a few customizations to existing flag actions.

  if (function_exists($flag_actions_form)) {

    $flag_actions_form($form, $flag, $edit);

  }

dependencies[] = flag

package = Flags

core = "7.x"

project = "flag"

 */

function flag_bookmark_enable() {

  // Load the flag API in case we want to use it when enabling.

  if (!flag_get_flags()) {

    // Install a demonstration flag only if no flag exists. This is to prevent

    // flag is overwritten or re-created.

    $flag = flag_flag::factory_by_entity_type('node');

    $configuration = array(

    );

    $flag->form_input($configuration);

    $flag->save();

}

/**

 */

function _flag_bookmark_install_get_suggested_node_types() {

  $preferred = array('article', 'story', 'forum', 'blog');

  }

  return $existing;

}

        'label' => t('Object has been flagged with any flag'),

      ),

      'flag_unflag' => array(

      ),

    ),

  );

  foreach ($flags as $flag) {

    $ops = array(

    );

    if (!module_exists('field_ui')) {

      unset($ops['flags_fields']);

  if (count($flags) > 1) {

    $header[] = t('Weight');

  }

  $output .= theme('table', array(

    'header' => $header,

    'rows' => $rows,

      $ops = array();

      if (!$flag->is_compatible()) {

        $flag_updates_needed = TRUE;

      }

      else {

        $ops['flags_enable'] = array('title' => t('enable'), 'href' => $flag->admin_path('edit'));

  }

  if (!empty($rows)) {

    $output .= theme('table', array('header' => $header, 'rows' => $rows));

  }

    '#title' => t('Token replacement'),

    '#type' => 'fieldset',

    '#description' =>

    '#collapsible' => TRUE,

    '#collapsed' => TRUE,

  );

/**

 * @file

 */

/**

 *   in hook_flag_default_flags().

 */

function flag_export_flags($flags = array(), $module = '', $indent = '') {

  $output = $indent . '$flags = array();' . "\n";

  foreach ($flags as $item) {

    if (is_object($item)) {

    if (substr($class, 0, 11) == 'FlagUpdate_') {

      // @todo: change this to work with the static class when we drop support

      // for PHP 5.2: see commit d5b517.

      // Cast to string, as decimals as array keys seem to be rounded down to

      // ints, WTF PHP?

      $version = (string) $update_handler->old_api_version;

    }

    // Update show_on_comment and show_on_entity properties to use new view

    if (!empty($flag->show_on_entity) || !empty($flag->show_on_comment)) {

      if ($entity_info = entity_get_info($flag->entity_type)) {

        foreach ($entity_info['view modes'] as $view_mode => $value) {

  $question = $flag->get_label($action . '_confirmation', $entity_id);

  $path = isset($_GET['destination']) ? $_GET['destination'] : '<front>';

  if ($action == 'flag') {

    // If the action 'flag', we're potentially about to create a new

    $flagging = $flag->new_flagging($entity_id);

    field_attach_form('flagging', $flagging, $form, $form_state);

    $form['#flagging'] = $flagging;

  }

  return confirm_form($form, $question, $path, '', $yes);

}

/**

 * Submit handler for the flag confirm form.

 *

/**

 * @file

 */

/**

/**

 * @file

 */

/**

    }

    // Select the first display option by default if this is a new flag.

    if (empty($this->fid)) {

      $defaults[$first_view_mode] = $first_view_mode;

    }

    );

  }

  /**

   * Returns the entity id, if it already exists.

   */

/**

 * @file

 */

/**

 *

 * This is the base class for all flag implementations. Notable derived

 * classes are flag_node and flag_comment.

 * - flag_flag::factory_by_array(), creates a flag handler from a configuration

 *   array. This is used by flag_get_default_flags() and the flag import form.

 * - flag_flag::factory_by_entity_type(), creates an empty flag handler for the

 *

 * The factory methods in turn all call the low-level function

 * flag_create_handler(), which obtains the correct handler for the flag, or if

  );

  /**

   *

   * The array keys should reflect the type of error being set. At this time,

   * the only "special" behavior related to the array keys is that

   *

   * @var array

   */

  /**

   * Creates a flag from a database row. Returns it.

    }

    if (!empty($row->type)) {

      $flag->types[] = $row->type;

    }

      'unflag_long' => '',

      'unflag_message' => '',

      'unflag_denied_text' => '',

      'link_type' => 'toggle',

      'weight' => 0,

    );

   */

  function form_input($form_values) {

    // Load the form fields indiscriminately unto the flag (we don't care about

    foreach ($form_values as $field => $value) {

      $this->$field = $value;

    }

   *   TRUE if the flag is enabled for this type and subtype.

   */

  function access_entity_enabled($entity_type, $content_subtype = NULL) {

  /**

   * Determine whether the flag should show a flag link in entity links.

   *   - to update field data an existing flagging. The $action parameter should

   *     be set to 'flag'. The Flagging entity will need to be loaded first with

   *     flagging_load().

   *

   * @return

   *   FALSE if some error occured (e.g., user has no permission, flag isn't

    if (!isset($account)) {

      $account = $GLOBALS['user'];

    }

    // Check access and applicability.

    if (!$skip_permission_check) {

      }

    }

    if (isset($flagging)) {

      $flagging->uid = $uid;

      $flagging->sid = $sid;

    // Perform the flagging or unflagging of this flag.

    if ($action == 'unflag') {

      if ($flagged) {

      }

    }

    elseif ($action == 'flag') {

      if (!$flagged) {

      }

      else {

      }

    }

  }

  /**

   *

   */

    field_attach_presave('flagging', $flagging);

    field_attach_insert('flagging', $flagging);

    // Invoke hook_entity_insert().

    module_invoke_all('entity_insert', $flagging, 'flagging');