deny duplicate node titles

If the food already exists, redirect them to the page. Popup denials makes the user feel like they've done something wrong.

can this be tweaked to do a slightly different validation?

I have similar issues. However, my site allows users to post links to other sites. I want to check for duplicates by checking one of the fields in the node being submitted against the content in the db fields.

so, instead of checking the node titles, i am checking a DB field. can i use this same code? where do i make the substitutions?

thanks!

j

I'm trying to get the above code to work, but I could use a little help.

I used CCK and the link field-type module to create a custom URL field for my Drupal forum submissions. I don't want people submitting duplicate URLs in this field. The URL is stored as the field "field_map_link_url" in the table "content_type_forum" of the MySQL database.

I've tried modifying the above code, but I can't get it to work. No matter what I enter in the URL field I get an error saying it's a duplicate. I think I'm screwing up the database query. This is my first time trying to write a custom module. I'd really appreciate if someone could show me how to get the code right. Thanks.

I'm trying to use the original code above with a content type 'product'. The content type has its title generated automatically using a combination of the token and auto nodetitles modules from a taxonomy field and a CCK field. I've added the line of code to see all the node data after creation and can see that the title is being generated correctly. I've also tried using the module weight module to make sure that this fires after both token and autonodetitles.

I also tried it with another content type that doesn't use autonodetitles and it works fine(except for the link output is weird-I'll worry about that later).

Can anyone offer any suggestions? Thank you so much. This is just what I need and seems to be soooooo close to working.

OK guys,
I think I have the code written now so that the function will check both the title and a specified field for a given content_type. I added the field check to the title check because it seems to me that you could still get dupes if the titles did not EXACTLY match. In other words, a new node titled "The Cars" would not be equal to "the cars" or "teh cars". By checking on a required field in addition to the title, I'm hoping to catch typos, and punctuation differences as well. Please correct me if I'm wrong with the above assumption.

In my version, I need to check 3 different content_types, so with the help of nevets, I set up a switch to check each of the 3 types.
The first and second cases in the switch are equivalent except for the name of the URL field that they are checking.
The third case in the switch is different, because in that case, I need to check that the title AND the field BOTH do not match an existing node. In other words, the title can match an existing node as long as the field does not also match, and vice-versa.

So here's the code:

<?php
// $Id: nodupescheck.module,v 0.1 2007/10/09 13:31:17 ZrO-1 Exp $

/**
 * No Dupes Check implements the nodeAPI hook - nodupescheck_nodeapi()
 * This function is to ensure that:
 * First, the submitted node titles do not match existing node titles
 * and Second, that the specified fields do not match existing fields.
 *
 * ->Developer Note: If this were to become a full module, then we should build a UI that lets the user select
 * the CCK content_types, and fields that need to be unique and pass them to this function.
 */

function nodupescheck_nodeapi(&$node, $op) {
  if ( $op == 'validate' ) {
    // We only care about nodes of a particular type - not all nodes,
    // since there are a few node types, and they each need to check different fields we make a switch for each type.
    switch ($node->type) {
      case 'content_type_provider': // the first type you want to restrict titles and fields on
        // For this content_type, we want to ensure that the node->title does not match an existing node.
        // First, we run a check on the title of the node. The variables we use are prefixed with t_* for the title
        $t_sql = "SELECT n.title, n.nid FROM {node} n WHERE type = '%s' AND title = '%s'";
        $t_results = db_query($t_sql, $node->type, $node->title);
        $t_existing = db_fetch_object($t_results);
        // NOTE: We get here on both inserts of new nodes, and updates of existing nodes.
        // For updates, we want to make sure the title does not match another one...
        // So first, we make sure it is an insert: (!$node->nid)
        // Or for updates that we have not just found the node being updated: ($t_exisiting->nid != $node->nid)
        if ( (!$node->nid || $t_existing->nid != $node->nid) && $t_existing->title == $node->title ) {
          // If there is a node with a matching title, we output an error-message stating so with a link to see the existing node
          $link = l(t('existing '.$node->type.' called '.$t_existing->title), "node/$t_existing->nid");
          form_set_error('title', t('Oops: There is already a provider called %title, click this link to see it: %link.', array('%title' => $node->title, '%link' => $link)));
        }
        // For this content_type, we want to also ensure that the "URL" field does not match an existing node.
        // Now, we run a check on the fields we want to ensure are also unique. The variables we use are prefixed with f_* for the field
        $f_sql = "SELECT f.field_provider_url, n.nid FROM {node} n JOIN {content_type_provider} f  USING(nid) WHERE type = '%s' AND field_provider_url[0]['url'] = '%s'";
        $f_results = db_query($f_sql, $node->type, $node->field_provider_url[0]['url']);
        $f_existing = db_fetch_object($f_results);
        // NOTE: Again, we get here on both inserts of new nodes, and updates of existing nodes.
        // For updates, we want to make sure the "URL" field does not match another one...
        // So first, we make sure it is an insert: (!$node->nid)
        // Or for updates that we have not just found the node being updated: ($f_exisiting->nid != $node->nid)
        if ( (!$node->nid || $f_existing->nid != $node->nid) && $f_existing->field_provider_url[0]['url'] == $node->field_provider_url[0]['url'] ) {
          $link = l(t('existing '.$node->type.' called '.$f_existing->title), "node/$f_existing->nid");
          form_set_error('title', t('Oops: There is already a provider called %title with the same address of %url, click this link to see it: %link.', array('%title' => $node->title, '%url' => $node->field_provider_url[0]['url'], '%link' => $link)));
        }
        break;
      
      case 'content_type_show':  // the second type you want to restrict titles on - Same as above, just different node type and field name
        $t_sql = "SELECT n.title, n.nid FROM {node} n WHERE type = '%s' AND title = '%s'";
        $t_results = db_query($t_sql, $node->type, $node->title);
        $t_existing = db_fetch_object($t_results);
        if ( (!$node->nid || $t_existing->nid != $node->nid) && $t_existing->title == $node->title ) {
          $link = l(t('existing '.$node->type.' called '.$t_existing->title), "node/$t_existing->nid");
          form_set_error('title', t('Oops: There is already a show called %title, click this link to see it: %link.', array('%title' => $node->title, '%link' => $link)));
        }
        $f_sql = "SELECT f.field_show_url, n.nid FROM {node} n JOIN {content_type_show} f  USING(nid) WHERE type = '%s' AND field_show_url[0]['url'] = '%s'";
        $f_results = db_query($f_sql, $node->type, $node->field_show_url[0]['url']);
        $f_existing = db_fetch_object($f_results);
        if ( (!$node->nid || $f_existing->nid != $node->nid) && $f_existing->field_show_url[0]['url'] == $node->field_show_url[0]['url'] ) {
          $link = l(t('existing '.$node->type.' called '.$f_existing->title), "node/$f_existing->nid");
          form_set_error('title', t('Oops: There is already a show called %title with the same address of %url, click this link to see it: %link.', array('%title' => $node->title, '%url' => $node->field_show_provider[0]['url'], '%link' => $link)));
        }
        break;
        
      // This content_type is a little different, because we need to check BOTH the title AND the node-reference field together
      // In other words, the title or the field can match an existing, but they both can't match an existing together
      case 'content_type_episode': // the third type you want to restrict titles on
        // First, for this content_type, we want to ensure that the node->title does not match an existing node.
        $t_sql = "SELECT n.title, n.nid FROM {node} n WHERE type = '%s' AND title = '%s'";
        $t_results = db_query($t_sql, $node->type, $node->title);
        $t_existing = db_fetch_object($t_results);
        // For this content_type, we want to also ensure that the "Show" node-reference field does not match an existing node with the same title.
        $f_sql = "SELECT f.field_episode_show, n.nid FROM {node} n JOIN {content_type_episode} f  USING(nid) WHERE type = '%s' AND field_episode_show[0]['nid'] = '%d'";
        $f_results = db_query($f_sql, $node->type, $node->field_episode_show[0]['nid']);
        $f_existing = db_fetch_object($f_results);
        if ( (!$node->nid || $t_existing->nid != $node->nid) && ($t_existing->title == $node->title && $f_existing->field_episode_show[0]['nid'] == $node->field_episode_show[0]['nid']) ) {
          $link = l(t('existing '.$node->type.' called '.$f_existing->title), "node/$f_existing->nid");
          form_set_error('title', t('Oops: There is already an episode called %title which is part of %show, click this link to see it: %link.', array('%title' => $node->title, '%show' => $node->field_episode_show[0]['view'], '%link' => $link)));
        }
        break;
    }
  }
}
?>

A word of caution to you: I am very new to PHP and drupal, so I can't say that the logic or code or syntax is perfect. It's probably very "cludgey". I have the greatest doubts about the third case... But hopefully we can work together to make it rock!
Thanks.
edit:
I also changed the link data, so the link shouldn't display weird anymore. Take a look and see if it will work for you.
/edit

Hey guys,
I'm still working on a more robust version of this function to check more than just titles, but for now I wanted to let you know that I have fixed the error message and link for when a dupe title is found.
Here is the code:

if ( ( ! $node->nid ||  $existing->nid != $node->nid ) && $existing->title == $node->title ) {
          $link = l('view the existing '.$node->type, 'node/'.$existing->nid, NULL, NULL, NULL, FALSE, FALSE);
          form_set_error('title', 'There is already a '.$node->type.' called '.$node->title.'. Here is a link to '.$link);
        }

The result of this is a single line that reads:
"There is already a [your content type] called [content type's title]. Here is a link to view the existing [your content type]."

Where [your content type] is the name of your content type, and [content type's title] is the node's title.

I have tested this feature out, and the link html and the link value are correct now.
Hope that helps...

I have figured out why my extra features have not been working. I don't know how much people who read this know about CCK types but I thought I'd share what I found so if someone is trying something similar to what I've been trying, they might find this helpful.

When you are calling $node->type you can use the "machine-readable" type for any node type. This includes CCK type nodes. You can find the machine-readable type for CCK nodes by looking at your content types in the admin section.
For an example: a CCK content type with the name "Foo Bar" might have a machine-readable type of "foobar"

That's all very straightforward. So what's the big deal?
Well, If you need to do a SQL query that checks a CCK node type, you can't just use the machine-readable name. You see, CCK types are stored in the database as content_type_*. So if we use our above example, we would have the following:

CCK Name = Foo Bar, machine-readable type = foobar, and db table = content_type_foobar

So when writing a function to query the db based on a particular CCK type, you would have something like this:

switch ($node->type) {
  case 'foobar': // the machine-readable type
    $sql = "SELECT * FROM {content_type_foobar}" // the actual table in the db for the type

The same holds true for CCK Multiple Value fields, where as example:
CCK Label = First Name, machine-readable name = field_first_name, and db table = content_field_first_name

This was really screwing me up before, so I wanted to post this to help others who might also be having trouble.

Hey guys,
I am so close to having the enhanced version of dupe check working I can smell it. There is just one last issue which I can't see how to fix in the code. I'm hoping someone can give me a pointer.
So here is what's happening:
1) When a new node is created, and the title and URL match an existing node, an error displays with both fields being in error.
That is what I want.
2) But, when the title is changed to be unique, but the URL is still the same as an existing node, the node passes and is created. Basically, the URL is not triggering an error by itself, but it does trigger correctly when the title also triggers.
Which is not what I want.

Here's the part of the code in question:

<?php
$sql = "SELECT f.field_provider_url_url, n.title, n.nid 
                FROM {node} n JOIN {content_type_provider} f  USING(nid) 
                WHERE type = '%s' AND title = '%s' AND field_provider_url_url = '%s'";
        $results = db_query($sql, $node->type, $node->title, $node->field_provider_url[0]['url']);
        $existing = db_fetch_object($results);
        // if the node is new, OR we're not updating/editing an existing node
        if (!$node->nid || $existing->nid != $node->nid) {
          // if an existing title matches the new title
          if ($existing->title == $node->title) {
            $link = l('view the existing '.$node->type, 'node/'.$existing->nid, NULL, NULL, NULL, FALSE, FALSE);
            form_set_error('title', 'Oops! There is already a '.$node->type.' called '.$node->title.'. Here is a link to '.$link.'. Please be absolutely sure that you are not creating a duplicate '.$node->type.'. Thanks!');
          }
          // if an existing URL field matches the new URL field
          if ($existing->field_provider_url_url == $node->field_provider_url[0]['url']) {
            $link = l('view the existing '.$node->type, 'node/'.$existing->nid, NULL, NULL, NULL, FALSE, FALSE);
            form_set_error('field_provider_url', 'Oops! There is already a '.$node->type.', called '.$node->title.', with the address '.$existing->field_provider_url_url.'. Here is a link to '.$link.'. Please be absolutely sure that you are not creating a duplicate '.$node->type.'. Thanks!');
          }
        }
?>

You see, the title and URL are being checked independently, but the URL is only caught if the title is also.
Any help here would be really appreciated. Thanks.

Hey gang.
I have a version of the function working which is checking title, field, and/or a combination of title and field. Because i still have some things I'd like to see done with this, and because i feel bad cluttering-up this thread, I have started a new topic over in the module-development forum. You can see the code I have and post replies here: http://drupal.org/node/182860

Thanks to nevets for all of the help.

I hope my work can be used by others here.

I've released a module called unique_field, which provides an interface for requiring that node titles or CCK fields have unique values. It is available from:

http://drupal.org/project/unique_field

I'd appreciate any comments or suggestions.

Subscribing...

Hi, I'm a newbie and i'm using drupal 6. I have a "wiki" content type and I just confused how to prevent duplicate title in drupal 6. Anyone can help me ? pls..