How to assign a user a title based on the number of created nodes?

Question

I want to set up a system where a user is given a title based on how much content they have created/published. So, for instance, if the user has published:

0 nodes  - Noobie
1+ nodes - Poster
10+ nodes - Frequent poster
20+ nodes - Super Poster
50+ nodes - God`

I'm wondering if there is a way to implement this in a Drupal site. I can think of a way to do it using database queries and a computed field, but I'm wondering if there might be a more efficient way to go about doing it.

Answer 1

I doubt there is a module for this, but hey. Do not let that bring you down, it's actually a great idea for a custom module! If you have a bit of patience, Drupal is very easy to learn once you get past the initial learning curve.

If you need a start, the module developper section and the create a module page on Drupal are great place to start.

There are many, many ways you could do this, but to start I would probably create a small module. Imagine it's called super_usernames, for the purpose of this post. I would just create a folder in sites/all/modules called `super_usernames. That folder would need to contain only 2 files:

super_usernames.info and super_usernames.module. The info file is very easy:

name = Super Usernames
description = Gives special credits to usernames depending on number of posts.
core = 7.x
files[] = super_usernames.module

The module file would need at the minimum just one hook to be defined. Hooks are just plain old php functions that use a simple naming convention in order to be executed by Drupal automatically.

The hook you need here is hook_node_view. Basically you want to add :

/*
 * Implements hook_node_load
 */
function super_usernames_node_view($node, $view_mode){
  $supported_node_types = array('page', 'article', 'blog'); // Supports default content types
  if (in_array($node->type, $supported_node_types) { 
    // query to get number of nodes this user has published
    $result = db_query("SELECT count(nid) as nodecount from {node} WHERE uid = %d", $node->uid);
     $row = db_fetch_object($result); 
     $node_count = $row->nodecount; // Easier to read
     switch ($node_count){
       case $node_count >= 50:
           $node->super_username = "God";
         break;
       case $node_count >= 20:
          $node->super_username = "Super Poster";
         break; 
       case $node_count >= 10:
          $node->super_username = " Frequent Poster";
         break;
       case  $node_count >= 1:  // same as > 0, but who cares...
           $node->super_username = "Poster";
         break;
       default:
           $node->super_username = "Noobie";                  
     }
  }
}

Now. After doing this, all your nodes should contain the dynamic value of the number of nodes posted by that node's author. This would be added on the fly on every page load from content-types articles, and pages.

You still need to have it displayed somewhere, though! This is where you would ideally create a sub-theme (so as not to hack a base theme). But for the purpose of this post, we will simply modify one file: node.tpl.php.

Check the theme you are using, by default it is bartik but the procedure is mostly the same whatever theme you are using.

Go into your themes/bartik/templates directory, open the node.tpl.php file. Locate where you want to add the super username in the html, and add this code snippet:

<?php if ($node->super_username): ?>
  <div class="superUsername">
    <?php print $node->super_username; ?>
  </div>
<?php endif; ?>

Now. One last step, you may need to clear the cache for changes to take effect. Devel module makes it easy, Drush makes it even easier. After this, you should have your super usernames dynamically shown on all the content-types defined in the supported_node_types array.

Hope this doesn't sound too complicated, it's actually quite trivial when you go through the process a few times. Feel free to message me or repost here if you need any help.

Happy coding, cheers!

• PS: This code has been slapped up from memory, nothing is tested but should be pretty close to a fully working example. Your mileage may vary, there may be typos in there.

Answer 2

A general-purpose module for use cases like this is User Points, which integrates with Rules. You could use rules to automatically add points when a user's content is published. You could even make some content types more valuable than others.

As for the titles, there is the User Badges module for D6, although there has been no official release for D7. In the meantime, depending on how complex your setup is, you could add a text select field to the user profile and use Field Permissions to forbid users from editing it. Then, you could use Rules to automatically set the data value at each threshold (1, 10, 20, etc.)

Answer 3

Another option to the already good suggestion of using the User Points + Rules modules, would be the Achievements module.

This is more geared towards mimicking the idea of gamification found on sites such as this, but will definitely give you full control if you're up for calling a few API functions.

Answer 4

The Goals module is yet another solution to answer this question.

Goals and Tasks are implemented using fieldable entities. So you can customize Goals via "Manage Fields" and/or "Manage display". E.g. to add your own fields, such as:

• descriptions.
• images.
• links to external resources.
• etc.

Head over to the Goals video which includes:

• a general introduction to the module.
• a demonstration to install, configure and use it.
• samples of how it uses the Rules modules to do its magic (i.e. to track the progress of a user to achieve the various roles.

Using the Goals Extras sub-module it integrates with the User Points module also.

Measuring the number of nodes published by a user (as in your question here), would really be like a getting started with this module: each of the 5 examples would become "a" Goal, whereas the actual "Tasks" would consists of just "publishing a node".

Even though your question (requirements) doesn't seem to include that, you could take it a bit further. E.g. by only taking into account 1 published node per day (so a user publishing 3 nodes on the same day would only count for 1).

All this can be done with site building features only (no custom code involved), though hooks are available to integrate it in custom coding also).

For more details, refer to its Community Documentation. For some details about how it differs from the Achievements module, refer to What is the difference with the Achievements module, which states:

The Goals module is built around using the admin interface configuration. Plus, goals and tasks within the Goals module are fieldable entities, so you have the flexibility to add additional fields and incorporate these entities into views.

I can't speak definitively for the Achievements module, but my best understanding is that it relies heavily on custom coding to handle many of the functions.

Disclosure: I'm the maintainer of this module.