/drupal7/sites/all/modules/flag/includes/flag/flag_flag.inc - Diff - Club Drupal - Forge Centrale Marseille

Révision 76e2e7c3

Ajouté par Assos Assos il y a environ 10 ans

ID 76e2e7c3c67fc47eae4b1040e925e614d764f206
Parent 6331c987
Enfant 6fd71452

Weekly update of contrib modules

     /**
      * @file
      *  Contains the flag_flag class.
      *  Flag type classes use an object oriented style inspired by that
      *  of Views 2.
      * Contains the flag_flag class.
      * Flag type classes use an object oriented style inspired by that
      * of Views 2.
      */
     /**
      * This abstract class represents a flag, or, in Views 2 terminology, "a handler".
      * This abstract class represents a flag, or, in Views 2 terminology,
      * "a handler".
+     *
      * 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
      *   given entity type. This is used when a new or dummy flag handler is required
      *   and there is no configuration yet.
      *   given entity type. This is used when a new or dummy flag handler is
      *   required and there is no configuration yet.
+     *
      * The factory methods in turn all call the low-level function
      * flag_create_handler(), which obtains the correct handler for the flag, or if
-...
       );
       /**
        * An associative array containing textual errors that may be created during validation.
        * An associative array containing textual errors that may be created during
        * validation.
+       *
        * 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
        */
       var $errors = array();
       public $errors = array();
       /**
        * Creates a flag from a database row. Returns it.
-...
+        }
         if (!empty($row->type)) {
           // The loop loading from the database should further populate this property.
           // The loop loading from the database should further populate this
           // property.
           $flag->types[] = $row->type;
+        }
-...
           'unflag_long' => '',
           'unflag_message' => '',
           'unflag_denied_text' => '',
           // The link type used by the flag, as defined in hook_flag_link_type_info().
           // The link type used by the flag, as defined in
           // hook_flag_link_type_info().
           'link_type' => 'toggle',
           'weight' => 0,
         );
-...
        */
       function form_input($form_values) {
         // Load the form fields indiscriminately unto the flag (we don't care about
         // stray FormAPI fields because we aren't touching unknown properties anyway.
         // stray FormAPI fields because we aren't touching unknown properties
         // anyway).
         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) {
        $entity_type_matches = ($this->entity_type == $entity_type);
        $sub_type_matches = FALSE;
        if (!isset($content_subtype) || !count($this->types)) {
          // Subtype automatically matches if we're not asked about it,
          // or if the flag applies to all subtypes.
          $sub_type_matches = TRUE;
+       }
        else {
          $sub_type_matches = in_array($content_subtype, $this->types);
+       }
        return $entity_type_matches && $sub_type_matches;
+     }
         $entity_type_matches = ($this->entity_type == $entity_type);
         $sub_type_matches = FALSE;
         if (!isset($content_subtype) || !count($this->types)) {
           // Subtype automatically matches if we're not asked about it,
           // or if the flag applies to all subtypes.
           $sub_type_matches = TRUE;
+        }
         else {
           $sub_type_matches = in_array($content_subtype, $this->types);
+        }
         return $entity_type_matches && $sub_type_matches;
+      }
       /**
        * 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().
        *  As with Drupal core API functions for saving entities, no validation of
        *  Field API fields is performed here. It is the responsibility of the caller
        *  to take care of Field API validation, using either
        *  field_attach_form_validate() or field_attach_validate().
+       *
        * @return
        *   FALSE if some error occured (e.g., user has no permission, flag isn't
-...
         if (!isset($account)) {
           $account = $GLOBALS['user'];
+        }
         if (!$account) {
           return FALSE;
+        }
         // Check access and applicability.
         if (!$skip_permission_check) {
-...
+          }
+        }
         // Set our uid and sid to the flagging object.
         // @todo: Discuss: Core wraps everything in a try { }, should we?
         $existing_flagging_id = $this->_is_flagged($entity_id, $uid, $sid);
         $flagged = (bool) $existing_flagging_id;
         // Ensure we have a Flagging entity and it is correctly formed.
         if (isset($flagging)) {
           // We were given a Flagging entity.
           // Ensure that it has the uid and sid that we were also given.
           $flagging->uid = $uid;
           $flagging->sid = $sid;
+        }
         // @todo: Discuss: Should we call field_attach_validate()? None of the
         // entities in core does this (fields entered through forms are already
         // validated).
         //
         // @todo: Discuss: Core wraps everything in a try { }, should we?
           // This is an ugly hack to preserve previous behaviour.
           $flagging->given_as_parameter = TRUE;
+        }
         else {
           // We were not given a Flagging entity.
           if ($flagged) {
             // Load the existing Flagging entity.
             $flagging = flagging_load($existing_flagging_id);
+          }
           else {
             // Construct a new Flagging entity to flag with.
             $flagging = $this->new_flagging($entity_id, $uid, $sid);
+          }
+        }
         // Perform the flagging or unflagging of this flag.
         $existing_flagging_id = $this->_is_flagged($entity_id, $uid, $sid);
         $flagged = (bool) $existing_flagging_id;
         if ($action == 'unflag') {
           if ($this->uses_anonymous_cookies()) {
             $this->_unflag_anonymous($entity_id);
+          }
           if ($flagged) {
             if (!isset($flagging)) {
               $flagging = flagging_load($existing_flagging_id);
+            }
             $transaction = db_transaction();
             try {
               // Note the order: We decrease the count first so hooks have accurate
               // data, then invoke hooks, then delete the flagging entity.
               $this->_decrease_count($entity_id);
               module_invoke_all('flag_unflag', $this, $entity_id, $account, $flagging);
               // Invoke Rules event.
               if (module_exists('rules')) {
                 $event_name = 'flag_unflagged_' . $this->name;
                 // We only support flags on entities.
                 if (entity_get_info($this->entity_type)) {
                   $variables = array(
                     'flag' => $this,
                     'flagged_' . $this->entity_type => $entity_id,
                     'flagging_user' => $account,
                     'flagging' => $flagging,
                   );
                   rules_invoke_event_by_args($event_name, $variables);
+                }
+              }
               $this->_delete_flagging($flagging);
               $this->_unflag($entity_id, $flagging->flagging_id);
+            }
             catch (Exception $e) {
               $transaction->rollback();
               watchdog_exception('flag', $e);
               throw $e;
+            }
             $this->flagging_delete($flagging, $entity_id, $account);
+          }
           // We do nothing in the case of an attempt to unflag something that isn't
           // actually flagged.
+        }
         elseif ($action == 'flag') {
           if ($this->uses_anonymous_cookies()) {
             $this->_flag_anonymous($entity_id);
+          }
           // By definition there is no flagging entity yet, but we may have been
           // passed one in to save.
           if (!isset($flagging)) {
             // Construct a new flagging object if we weren't passed one.
             $flagging = $this->new_flagging($entity_id, $uid, $sid);
+          }
           // Invoke hook_entity_presave().
           // In the case that we have been passed in a flagging entity to update,
           // this is technically still a presave, even though the {flagging} table
           // itself is not changed.
           module_invoke_all('entity_presave', $flagging, 'flagging');
           if (!$flagged) {
             // The entity is unflagged.
             // Save the flagging entity (just our table).
             $this->_flag($flagging);
             $this->_increase_count($entity_id);
             // We're writing out a flagging entity even when we aren't passed one
             // (e.g., when flagging via JavaScript toggle links); in this case
             // Field API will assign the fields their default values.
             $this->_insert_flagging($flagging);
             module_invoke_all('flag_flag', $this, $entity_id, $account, $flagging);
             // Invoke Rules event.
             if (module_exists('rules')) {
               $event_name = 'flag_flagged_' . $this->name;
               // We only support flags on entities.
               if (entity_get_info($this->entity_type)) {
                 $variables = array(
                   'flag' => $this,
                   'flagged_' . $this->entity_type => $entity_id,
                   'flagging_user' => $account,
                   'flagging' => $this->get_flagging($entity_id, $account->uid),
                 );
                 rules_invoke_event_by_args($event_name, $variables);
+              }
+            }
             $this->flagging_insert($flagging, $entity_id, $account);
+          }
           else {
             // Nothing to do. Item is already flagged.
             //
             // Except in the case a $flagging object is one that was passed in: in
             // this case we're being requested to update the flagging. This occurs,
             // for example, when the user updates the flagging entity form.
             if (!empty($flagging->flagging_id)) {
               $this->_update_flagging($flagging);
+            }
             $this->flagging_update($flagging, $entity_id, $account);
+          }
+        }
-...
+      }
       /**
        * The entity CRUD methods _{insert,update,delete}_flagging() are for private
        * use by the flag() method.
        * Create a new Flagging to flag an entity.
+       *
        * The reason programmers should not call them directly is because a flagging
        * operation is also accompanied by some bookkeeping (calling hooks, updating
        * counters) or access control. These tasks are handled by the flag() method.
        * @param $flagging
        *  The flagging entity that is to be removed.
        * @param $entity_id
        *  The entity ID of entity being unflagged.
        * @param $account
        *  The account performing the unflagging.
        */
       private function _insert_flagging($flagging) {
       private function flagging_insert($flagging, $entity_id, $account) {
         if ($this->uses_anonymous_cookies()) {
           $this->_flag_anonymous($entity_id);
+        }
         // Invoke presave hooks.
         field_attach_presave('flagging', $flagging);
         // Invoke hook_entity_presave().
         module_invoke_all('entity_presave', $flagging, 'flagging');
         // Set the timestamp.
         $flagging->timestamp = REQUEST_TIME;
         // Save the flagging entity.
         drupal_write_record('flagging', $flagging);
         // Clear various caches; we don't want code running after us to report
         // wrong counts or false flaggings.
         drupal_static_reset('flag_get_user_flags');
         drupal_static_reset('flag_get_entity_flags');
         // Despite being named in the same pattern as the count API functions, these
         // query the {flagging} table, so are reset here.
         drupal_static_reset('flag_get_entity_flag_counts');
         drupal_static_reset('flag_get_user_flag_counts');
         $this->_increase_count($entity_id);
         // We're writing out a flagging entity even when we aren't passed one
         // (e.g., when flagging via JavaScript toggle links); in this case
         // Field API will assign the fields their default values.
         // Invoke insert hooks.
         field_attach_insert('flagging', $flagging);
         // Invoke hook_entity_insert().
         module_invoke_all('entity_insert', $flagging, 'flagging');
         module_invoke_all('flag_flag', $this, $entity_id, $account, $flagging);
         // Invoke Rules event.
         if (module_exists('rules')) {
           $this->invoke_rules_event('flag', $flagging, $entity_id, $account);
+        }
+      }
       private function _update_flagging($flagging) {
       /**
        * Invoke a Rules event in reaction to a flagging or unflagging.
+       *
        * @param $action
        *   Either 'flag' or 'unflag'.
        * @param $flagging
        *  The flagging entity that is to be removed.
        * @param $entity_id
        *  The entity ID of entity being unflagged.
        * @param $account
        *  The account performing the unflagging.
        */
       protected function invoke_rules_event($action, $flagging, $entity_id, $account) {
         // We only support flags on entities: do nothing in this class.
         // See flag_entity::invoke_rules_event().
         return;
+      }
       /**
        * Update a Flagging.
+       *
        * @param $flagging
        *  The flagging entity that is to be removed.
        * @param $entity_id
        *  The entity ID of entity being unflagged.
        * @param $account
        *  The account performing the unflagging.
        */
       private function flagging_update($flagging, $entity_id, $account) {
         // Invoke presave hooks.
         // This is technically still a presave, even though the {flagging} table
         // itself is not changed.
         field_attach_presave('flagging', $flagging);
         field_attach_update('flagging', $flagging);
         // Update the cache.
         entity_get_controller('flagging')->resetCache();
         // Invoke hook_entity_update().
         // Since there are no fields on the {flagging} table that can be
         // meaningfully changed, we don't perform an update on it. However, this
         // technically still counts as updating the flagging entity, since we update
         // its fields.
         module_invoke_all('entity_update', $flagging, 'flagging');
         // Invoke hook_entity_presave().
         module_invoke_all('entity_presave', $flagging, 'flagging');
         // This check exists solely to preserve previous behaviour with re-flagging.
         // TODO: consider removing it.
         if (!empty($flagging->given_as_parameter)) {
           field_attach_update('flagging', $flagging);
           // Update the cache.
           entity_get_controller('flagging')->resetCache();
           // Invoke hook_entity_update().
           // Since there are no fields on the {flagging} table that can be
           // meaningfully changed, we don't perform an update on it. However, this
           // technically still counts as updating the flagging entity, since we update
           // its fields.
           module_invoke_all('entity_update', $flagging, 'flagging');
+        }
+      }
       private function _delete_flagging($flagging) {
         field_attach_delete('flagging', $flagging);
         // Remove from the cache.
         entity_get_controller('flagging')->resetCache();
         // Invoke hook_entity_delete().
         module_invoke_all('entity_delete', $flagging, 'flagging');
       /**
        * Unflag an entity by deleting a Flagging.
+       *
        * @param $flagging
        *  The flagging entity that is to be removed.
        * @param $entity_id
        *  The entity ID of entity being unflagged.
        * @param $account
        *  The account performing the unflagging.
        */
       private function flagging_delete($flagging, $entity_id, $account) {
         if ($this->uses_anonymous_cookies()) {
           $this->_unflag_anonymous($entity_id);
+        }
         $transaction = db_transaction();
         try {
           // Note the order: We decrease the count first so hooks have accurate
           // data, then invoke hooks, then delete the flagging entity.
           $this->_decrease_count($entity_id);
           module_invoke_all('flag_unflag', $this, $entity_id, $account, $flagging);
           // Invoke Rules event.
           if (module_exists('rules')) {
             $this->invoke_rules_event('unflag', $flagging, $entity_id, $account);
+          }
           // Invoke hook_entity_delete().
           module_invoke_all('entity_delete', $flagging, 'flagging');
           // Delete field data.
           field_attach_delete('flagging', $flagging);
           // Delete the flagging entity.
           db_delete('flagging')->condition('flagging_id', $flagging->flagging_id)->execute();
           // Remove from the cache.
           entity_get_controller('flagging')->resetCache();
           // Clear various caches; we don't want code running after us to report
           // wrong counts or false flaggings.
           drupal_static_reset('flag_get_user_flags');
           drupal_static_reset('flag_get_entity_flags');
           // Despite being named in the same pattern as the count API functions, these
           // query the {flagging} table, so are reset here.
           drupal_static_reset('flag_get_entity_flag_counts');
           drupal_static_reset('flag_get_user_flag_counts');
+        }
         catch (Exception $e) {
           $transaction->rollback();
           watchdog_exception('flag', $e);
           throw $e;
+        }
+      }
       /**
-...
           ->fetchField();
+      }
       /**
        * A low-level method to flag an object.
+       *
        * You probably shouldn't call this raw private method: call the flag()
        * function instead.
+       *
        * @param
        *   The flagging record.
+       *
        * @private
        */
       function _flag($flagging) {
         // Set the timestamp.
         $flagging->timestamp = REQUEST_TIME;
         drupal_write_record('flagging', $flagging);
         // Clear various caches; we don't want code running after us to report
         // wrong counts or false flaggings.
         drupal_static_reset('flag_get_user_flags');
         drupal_static_reset('flag_get_entity_flags');
         // Despite being named in the same pattern as the count API functions, these
         // query the {flagging} table, so are reset here.
         drupal_static_reset('flag_get_entity_flag_counts');
         drupal_static_reset('flag_get_user_flag_counts');
+      }
       /**
        * A low-level method to unflag an object.
+       *
        * You probably shouldn't call this raw private method: call the flag()
        * function instead.
+       *
        * @private
        */
       function _unflag($entity_id, $flagging_id) {
         db_delete('flagging')->condition('flagging_id', $flagging_id)->execute();
         // Clear various caches; we don't want code running after us to report
         // wrong counts or false flaggings.
         drupal_static_reset('flag_get_user_flags');
         drupal_static_reset('flag_get_entity_flags');
         // Despite being named in the same pattern as the count API functions, these
         // query the {flagging} table, so are reset here.
         drupal_static_reset('flag_get_entity_flag_counts');
         drupal_static_reset('flag_get_user_flag_counts');
+      }
       /**
        * Increases the flag count for an object and clears the static counts cache.
+       *
-...
        *   The amount of counts to increasing. Defaults to 1.
+       *
        * @private
       */
        */
       function _increase_count($entity_id, $number = 1) {
         db_merge('flag_counts')
           ->key(array(
-...
        *   The amount of counts to decrease. Defaults to 1.
+       *
        * @private
       */
        */
       function _decrease_count($entity_id, $number = 1) {
         // Delete rows with count 0, for data consistency and space-saving.
         // Done before the db_update() to prevent out-of-bounds errors on "count".
-...
        * @param $entity_id
        *   The ID in whose context to interpret tokens. If not given, only global
        *   tokens will be substituted.
+       *
        * @return
        *   The processed label.
        */
-...
        * @param $variables = array()
        *  An array of further variables to pass to theme('flag'). For the full list
        *  of parameters, see flag.tpl.php. Of particular interest:
        *  - after_flagging: Set to TRUE if this flag link is being displayed as the result
        *    of a flagging action.
        *  - after_flagging: Set to TRUE if this flag link is being displayed as the
        *    result of a flagging action.
        *  - errors: An array of error messages.
+       *
        * @return

Formats disponibles : Unified diff

Projet

Général

Profil

Club Drupal

Révision 76e2e7c3

Ajouté par Assos Assos il y a environ 10 ans