AGL.inc

File

tripal_pub/includes/importers/AGL.inc
View source
  1. <?php

  2. /**

  3.  *

  4.  */

  5. function tripal_pub_remote_alter_form_AGL($form, $form_state) {

  6. 

  7.   $num_criteria = $form['num_criteria']['#default_value'];

  8. 

  9.   // So far we haven't been able to get AGL to filter results to only

  10.   // include pubs by the XX number days in the past.  So, we will

  11.   // change the 'days' element to be the year to query

  12.   $form['days']['#title'] = t('Year');

  13.   $form['days']['#description']  = t('Please enter a year to limit records by the year they were published, created or modified in the database.');

  14. 

  15.   // The Journal Name filter doesn't seem to work, so remove it

  16.   for($i = 1; $i <= $num_criteria; $i++) {

  17.     unset($form['criteria'][$i]["scope-$i"]['#options']['journal']);

  18.   }

  19.   return $form;

  20. }

  21. /**

  22.  *

  23.  */

  24. function tripal_pub_remote_validate_form_AGL($form, $form_state) {

  25.   $days =  trim($form_state['values']["days"]);

  26.   $num_criteria = $form['num_criteria']['#default_value'];

  27. 

  28.   if ($days and !preg_match('/^\d\d\d\d$/', $days)) {

  29.     form_set_error("days", "Please enter a four digit year.");

  30.   }

  31. 

  32.   $num_ids = 0;

  33.   for ($i = 1; $i <= $num_criteria; $i++) {

  34.     $search_terms =  trim($form_state['values']["search_terms-$i"]);

  35.     $scope =  $form_state['values']["scope-$i"];

  36.     if ($scope == 'id' and !preg_match('/^AGL:\d+$/', $search_terms)) {

  37.       form_set_error("search_terms-$i", "The AGL accession be a numeric value, prefixed with 'AGL:' (e.g. AGL:3890740).");

  38.     }

  39.     if ($scope == 'id') {

  40.       $num_ids++;

  41.     }

  42.     if($num_ids > 1) {

  43.       form_set_error("search_terms-$i", "Unfortuantely, the AGL importer can only support a single accession at a time. Please remove the others.");

  44.     }

  45.   }

  46.   return $form;

  47. }

  48. /**

  49.  *

  50.  */

  51. function tripal_pub_remote_search_AGL($search_array, $num_to_retrieve, $pager_id) {

  52.   // get some values from the serach array

  53.   $num_criteria = $search_array['num_criteria'];

  54.   $days = $search_array['days'];

  55. 

  56.   // set some defaults

  57.   $search_array['limit'] = $num_to_retrieve;

  58. 

  59.   // To build the CCL search string we want to have a single entry for 'author', 'title', 'abstract'

  60.   // or 'id', and also the corresponding 'not for each of those.

  61.   // But the search form allows the user to have multiple rows of the same type. So, we will build the

  62.   // search string separately for each category and it's negative category (if NOT is selected as the op)

  63.   // and at the end we will put them together into a single search string.  We need to keep

  64.   // track of the first entry of any category because it will not have an op (e.g. 'or' or 'and') but the

  65.   // operation will be pushed out to separate the categories.  The op for any second or third instance of

  66.   // the same category will be included within the search string for the catgory.

  67.   $ccl = '';

  68.   $title = '';

  69.   $author = '';

  70.   $abstract = '';

  71.   $id = '';

  72.   $any = '';

  73.   $negate_title = '';

  74.   $negate_author = '';

  75.   $negate_abstract = '';

  76.   $negate_id = '';

  77.   $negate_any = '';

  78.   $order = array();

  79.   $first_abstract = 1;

  80.   $first_author = 1;

  81.   $first_title = 1;

  82.   $first_id = 1;

  83.   $first_any = 1;

  84.   $first_negate_abstract = 1;

  85.   $first_negate_author = 1;

  86.   $first_negate_title = 1;

  87.   $first_negate_id = 1;

  88.   $first_negate_any = 1;

  89.   for ($i = 1; $i <= $num_criteria; $i++) {

  90.     $search_terms = trim($search_array['criteria'][$i]['search_terms']);

  91.     $scope = $search_array['criteria'][$i]['scope'];

  92.     $is_phrase = $search_array['criteria'][$i]['is_phrase'];

  93.     $op = $search_array['criteria'][$i]['operation'];

  94. 

  95.     if ($op) {

  96.       $op = strtolower($op);

  97.     }

  98.     $search_terms = trim($search_terms);

  99.     // if this is not a phrase then make sure the AND and OR are lower-case

  100.     if (!$is_phrase) {

  101.       $search_terms = preg_replace('/ OR /', ' or ', $search_terms);

  102.       $search_terms = preg_replace('/ AND /', ' and ', $search_terms);

  103.     }

  104.     // else make sure the search terms are surrounded by quotes

  105.     else {

  106.       $search_terms = "\"$search_terms\"";

  107.     }

  108. 

  109.     // if this is a 'not' operation then we want to change it to an

  110.     // and

  111.     $negate = '';

  112.     if ($op == 'not') {

  113.       $scope = "negate_$scope";

  114.       $op = 'or';

  115.     }

  116.     $order[] = array('scope' => $scope, 'op' => $op);

  117. 

  118.     // build each category

  119.     if ($scope == 'title') {

  120.       if ($first_title) {

  121.         $title .= "($search_terms) ";

  122.         $first_title = 0;

  123.       }

  124.       else {

  125.         $title .= "$op ($search_terms) ";

  126.       }

  127.     }

  128.     if ($scope == 'negate_title') {

  129.       if ($first_negate_title) {

  130.         $negate_title .= "($search_terms) ";

  131.         $first_negate_title = 0;

  132.       }

  133.       else {

  134.         $negate_title .= "$op ($search_terms) ";

  135.       }

  136.     }

  137.     elseif ($scope == 'author') {

  138.       if ($first_author) {

  139.         $author .= "($search_terms) ";

  140.         $first_author = 0;

  141.       }

  142.       else {

  143.         $author .= "$op ($search_terms) ";

  144.       }

  145.     }

  146.     elseif ($scope == 'negate_author') {

  147.       if ($first_negate_author) {

  148.         $negate_author .= "($search_terms) ";

  149.         $first_negate_author = 0;

  150.       }

  151.       else {

  152.         $negate_author .= "$op ($search_terms) ";

  153.       }

  154.     }

  155.     elseif ($scope == 'abstract') {

  156.       if ($first_abstract) {

  157.         $abstract .= "($search_terms) ";

  158.         $first_abstract = 0;

  159.       }

  160.       else {

  161.         $abstract .= "$op ($search_terms) ";

  162.       }

  163.     }

  164.     elseif ($scope == 'negate_abstract') {

  165.       if ($first_negate_abstract) {

  166.         $negate_abstract .= "($search_terms) ";

  167.         $first_negate_abstract = 0;

  168.       }

  169.       else {

  170.         $negate_abstract .= "$op ($search_terms) ";

  171.       }

  172.     }

  173.     elseif ($scope == 'journal') {

  174.       if ($first_journal) {

  175.         $journal .= "($search_terms) ";

  176.         $first_jounral = 0;

  177.       }

  178.       else {

  179.         $journal .= "$op ($search_terms) ";

  180.       }

  181.     }

  182.     elseif ($scope == 'negate_journal') {

  183.       if ($first_negate_journal) {

  184.         $negate_journal .= "($search_terms) ";

  185.         $first_negate_journal = 0;

  186.       }

  187.       else {

  188.         $negate_journal .= "$op ($search_terms) ";

  189.       }

  190.     }

  191.     elseif ($scope == 'id') {

  192.       if ($first_id) {

  193.         $id .= "(" . preg_replace('/AGL:([^\s]*)/', '$1', $search_terms) . ") ";

  194.         $first_id = 0;

  195.       }

  196.       else {

  197.         $id .= "$op (" . preg_replace('/AGL:([^\s]*)/', '$1', $search_terms) . ") ";

  198.       }

  199.     }

  200.     elseif ($scope == 'negate_id') {

  201.       if ($first_negate_id) {

  202.         $negate_id .= "(" . preg_replace('/AGL:([^\s]*)/', '$1', $search_terms) . ") ";

  203.         $first_negate_id = 0;

  204.       }

  205.       else {

  206.         $negate_id .= "$op (" . preg_replace('/AGL:([^\s]*)/', '$1', $search_terms) . ") ";

  207.       }

  208.     }

  209.     elseif ($scope == 'any'){

  210.       if ($first_any) {

  211.         $any .= "($search_terms) ";

  212.         $first_any = 0;

  213.       }

  214.       else {

  215.         $any .= "$op ($search_terms) ";

  216.       }

  217.     }

  218.     elseif ($scope == 'negate_any'){

  219.       if ($first_negate_any) {

  220.         $negate_any .= "($search_terms) ";

  221.         $first_any = 0;

  222.       }

  223.       else {

  224.         $negate_any .= "$op ($search_terms) ";

  225.       }

  226.     }

  227.   }

  228.   // now build the CCL string in order

  229.   $abstract_done = 0;

  230.   $author_done = 0;

  231.   $journal_done = 0;

  232.   $title_done = 0;

  233.   $id_done = 0;

  234.   $any_done = 0;

  235.   $negate_abstract_done = 0;

  236.   $negate_journal_done = 0;

  237.   $negate_author_done = 0;

  238.   $negate_title_done = 0;

  239.   $negate_id_done = 0;

  240.   $negate_any_done = 0;

  241.   for ($i = 0; $i < count($order) ; $i++) {

  242.     if ($order[$i]['scope'] == 'abstract' and !$abstract_done) {

  243.       $op = $order[$i]['op'];

  244.       $ccl .= "$op abstract=($abstract) ";

  245.       $abstract_done = 1;

  246.     }

  247.     if ($order[$i]['scope'] == 'negate_abstract' and !$negate_abstract_done) {

  248.       $ccl .= "not abstract=($negate_abstract) ";

  249.       $negate_abstract_done = 1;

  250.     }

  251.     if ($order[$i]['scope'] == 'author' and !$author_done) {

  252.       $op = $order[$i]['op'];

  253.       $ccl .= "$op author=($author) ";

  254.       $author_done = 1;

  255.     }

  256.     if ($order[$i]['scope'] == 'negate_author' and !$negate_author_done) {

  257.       $ccl .= "not author=($negate_author) ";

  258.       $negate_author_done = 1;

  259.     }

  260.     if ($order[$i]['scope'] == 'journal' and !$journal_done) {

  261.       $op = $order[$i]['op'];

  262.       $ccl .= "$op journal=($journal) ";

  263.       $journal_done = 1;

  264.     }

  265.     if ($order[$i]['scope'] == 'negate_journal' and !$negate_journal_done) {

  266.       $ccl .= "not author=($negate_journal) ";

  267.       $negate_journal_done = 1;

  268.     }

  269.     if ($order[$i]['scope'] == 'id' and !$id_done) {

  270.       $op = $order[$i]['op'];

  271.       $ccl .= "$op id=($id) ";

  272.       $id_done = 1;

  273.     }

  274.     if ($order[$i]['scope'] == 'negate_id' and !$negate_id_done) {

  275.       $ccl .= "not id=($negate_id) ";

  276.       $negate_id_done = 1;

  277.     }

  278.     if ($order[$i]['scope'] == 'title' and !$title_done) {

  279.       $op = $order[$i]['op'];

  280.       $ccl .= "$op title=($title) ";

  281.       $title_done = 1;

  282.     }

  283.     if ($order[$i]['scope'] == 'negate_title' and !$negate_title_done) {

  284.       $ccl .= "not title=($negate_title) ";

  285.       $negate_title_done = 1;

  286.     }

  287.     if ($order[$i]['scope'] == 'any' and !$any_done) {

  288.       $op = $order[$i]['op'];

  289.       $ccl .= "$op ($any) ";

  290.       $any_done = 1;

  291.     }

  292.     if ($order[$i]['scope'] == 'negate_any' and !$negate_any_done) {

  293.       $ccl .= "not ($negate_any) ";

  294.       $negate_any_done = 1;

  295.     }

  296.   }

  297. 

  298.   // for AGL the 'days' form element was converted to represent the year

  299.   if ($days) {

  300.     $ccl .= "and year=($days)";

  301.   }

  302. 

  303.   // remove any preceeding 'and' or 'or'

  304.   $ccl = preg_replace('/^\s*(and|or)/', '', $ccl);

  305. 

  306.   // yaz_connect() prepares for a connection to a Z39.50 server. This function is non-blocking

  307.   // and does not attempt to establish a connection - it merely prepares a connect to be

  308.   // performed later when yaz_wait() is called.

  309.   //$yazc = yaz_connect('agricola.nal.usda.gov:7090/voyager'); // NAL Catalog

  310.   $yazc = yaz_connect('agricola.nal.usda.gov:7190/voyager');  // NAL Article Citation Database

  311. 

  312.   // use the USMARC record type.  But OPAC is also supported by Agricola

  313.   yaz_syntax($yazc, "usmarc");

  314. 

  315.   // the search query is built using CCL, we need to first

  316.   // configure it so it can map the attributes to defined identifiers

  317.   // The attribute set used by AGL can be found at the bottom of this page:

  318.   // http://agricola.nal.usda.gov/help/z3950.html

  319.   //

  320.   // More in depth details:  http://www.loc.gov/z3950/agency/bib1.html

  321.   //

  322.   // CCL Syntax: http://www.indexdata.com/yaz/doc/tools.html#CCL

  323.   //

  324.   $fields = array(

  325.     "title"    => "u=4",

  326.     "author"   => "u=1003",

  327.     "abstract" => "u=62",

  328.     "id"       => "u=12",

  329.     "year"     => "u=30 r=o", 

  330.     "journal"  => "u=1033"

  331.     );

  332.     yaz_ccl_conf($yazc, $fields);

  333. 

  334.     if (!yaz_ccl_parse($yazc, $ccl, $cclresult)) {

  335.       drupal_set_message('Error parsing search string: ' . $cclresult["errorstring"], "error");

  336.       watchdog('tpub_import', 'Error: %errstr', array('%errstr' => $cclresult["errorstring"]), WATCHDOG_ERROR);

  337.       return array();

  338.     }

  339.     $search_str = $cclresult["rpn"];

  340. 

  341.     $search_array['search_string'] = $search_str;

  342. 

  343.     // save the YAZ connection in the session for use by other functions

  344.     $_SESSION['tripal_pub_AGL_query'][$search_str]['yaz_connection'] = $yazc;

  345. 

  346.     //dpm($search_array);

  347.     // we want to get the list of pubs using the search terms but using a Drupal style pager

  348.     $pubs = tripal_pager_callback('tripal_pub_AGL_range',  $num_to_retrieve, $pager_id,

  349.     'tripal_pub_AGL_count', $search_array);

  350. 

  351.     // close the connection

  352.     unset($_SESSION['tripal_pub_AGL_query'][$search_str]['yaz_connection']);

  353.     yaz_close($yazc);

  354. 

  355.     return $pubs;

  356. }

  357. /*

  358.  * This function is used as the callback function when used with the

  359.  * tripal_pager_callback function.  This function returns a count of

  360.  * the dataset to be paged.

  361.  */

  362. function tripal_pub_AGL_count($search_array) {

  363.   $search_str = $search_array['search_string'];

  364.   $days       = $search_array['days'];

  365.   $limit      = $search_array['limit'];

  366. 

  367.   $yazc = $_SESSION['tripal_pub_AGL_query'][$search_str]['yaz_connection'];

  368.   //yaz_sort($yazc, "1=31 id"); // sort by publication date descending

  369.   if (!yaz_search($yazc, "rpn", $search_str)){

  370.     $error_no = yaz_errno($yazc);

  371.     $error_msg = yaz_error($yazc);

  372.     $additional = yaz_addinfo($yazc);

  373.     if ($additional != $error_msg) {

  374.       $error_msg .= " $additional";

  375.     }

  376.     drupal_set_message("ERROR preparing search at AGL: ($error_no) $error_msg", "error");

  377.     watchdog('tpub_import', "ERROR preparing search at AGL: (%error_no) %error_msg",

  378.               array('%error_no' => $error_no, '%error_msg' => $error_msg), WATCHDOG_ERROR);

  379.     return 0;

  380.   }

  381.   if (!yaz_wait()) {

  382.     $error_no = yaz_errno($yazc);

  383.     $error_msg = yaz_error($yazc);

  384.     $additional = yaz_addinfo($yazc);

  385.     if ($additional != $error_msg) {

  386.       $error_msg .= " $additional";

  387.     }

  388.     drupal_set_message("ERROR waiting on search at AGL: ($error_no) $error_msg", "error");

  389.     watchdog('tpub_import', "ERROR waiting on search at AGL: (%error_no) %error_msg",

  390.               array('%error_no' => $error_no, '%error_msg' => $error_msg), WATCHDOG_ERROR);

  391.     return 0;

  392.   }

  393. 

  394.   // get the total number of results from the serach

  395.   $count = yaz_hits($yazc);

  396.   $_SESSION['tripal_pub_AGL_query'][$search_str]['Count'] = $count;

  397.   return $count;

  398. }

  399. 

  400. /*

  401.  * This function is used as the callback function when used with the

  402.  * tripal_pager_callback function.  This function returns the results

  403.  * within the specified range

  404.  */

  405. function tripal_pub_AGL_range($search_array, $start = 0, $limit = 10) {

  406.   $pubs = array();

  407. 

  408.   $search_str = $search_array['search_string'];

  409.   $days       = $search_array['days'];

  410.   $limit      = $search_array['limit'];

  411. 

  412.   $yazc  = $_SESSION['tripal_pub_AGL_query'][$search_str]['yaz_connection'];

  413.   $count = $_SESSION['tripal_pub_AGL_query'][$search_str]['Count'];

  414.   yaz_range($yazc, 1, $num_pubs);

  415.   if (!yaz_present($yazc)) {

  416.     $error_no = yaz_errno($yazc);

  417.     $error_msg = yaz_error($yazc);

  418.     $additional = yaz_addinfo($yazc);

  419.     if ($additional != $error_msg) {

  420.       $error_msg .= " $additional";

  421.     }

  422.     drupal_set_message("ERROR waiting on search at AGL: ($error_no) $error_msg", "error");

  423.     watchdog('tpub_import', "ERROR waiting on search at AGL: (%error_no) %error_msg",

  424.               array('%error_no' => $error_no, '%error_msg' => $error_msg), WATCHDOG_ERROR);

  425.     return $pubs;

  426.   }

  427.    

  428.   if ($start + $limit > $count) {

  429.     $limit = $count - $start;

  430.   }

  431.   for($i = $start; $i < $start + $limit; $i++) {

  432.     $pub_xml = yaz_record($yazc, $i + 1, 'xml; charset=marc-8,utf-8');

  433.     $pub     = tripal_pub_AGL_parse_pubxml($pub_xml);

  434.     $pubs[]  = $pub;

  435.   }

  436.   return $pubs;

  437. }

  438. 

  439. /*

  440.  * Description of XML format:

  441.  * http://www.loc.gov/marc/bibliographic/bdsummary.html

  442.  *

  443.  */

  444. function tripal_pub_AGL_parse_pubxml($pub_xml) {

  445.   $pub = array();

  446. 

  447.   // we will set the default publication type as a journal article. The NAL

  448.   // dataset doesn't specify an article type so we'll have to glean the type

  449.   // from other information (e.g. series name has 'Proceedings' in it)

  450.   $pub['Publication Type'][0] = 'Journal Article';

  451. 

  452.   if (!$pub_xml) {

  453.     return $pub;

  454.   }

  455. 

  456.   // read the XML and iterate through it.

  457.   $xml = new XMLReader();

  458.   $xml->xml(trim($pub_xml));

  459.   while ($xml->read()) {

  460.     $element = $xml->name;

  461. 

  462.     if ($xml->nodeType == XMLReader::ELEMENT and $element == 'controlfield') {

  463.       $tag = $xml->getAttribute('tag');

  464.       $xml->read();

  465.       $value = $xml->value;

  466.       switch ($tag) {

  467.         case '001':  // control number

  468.           $pub['Publication Accession'] = $value;

  469.           break;

  470.         case '003':  // control number identifier

  471.           break;

  472.         case '005':  // datea nd time of latest transaction

  473.           break;

  474.         case '006':  // fixed-length data elemetns

  475.           break;

  476.         case '007':  // physical description fixed field

  477.           break;

  478.         case '008':  // fixed length data elements

  479.           $month = array(

  480.             '01' => 'Jan', '02' => 'Feb', '03' => 'Mar', 

  481.             '04' => 'Apr', '05' => 'May', '06' => 'Jun', 

  482.             '07' => 'Jul', '08' => 'Aug', '09' => 'Sep', 

  483.             '10' => 'Oct', '11' => 'Nov', '12' => 'Dec'

  484.             );

  485.             $date0 = substr($value, 0, 6);  // date entered on file

  486.             $date1 = substr($value, 7, 4);  // year of publication

  487.             $date2 = substr($value, 11, 4); // month of publication

  488.             $place = substr($value, 15, 3);

  489.             $lang  = substr($value, 35, 3);

  490.             if (preg_match('/\d\d\d\d/', $date1)) {

  491.               $pub['Year'] = $date1;

  492.               $pub['Publication Date'] = $date1;

  493.             }

  494.             if (preg_match('/\d\d/', $date2)) {

  495.               $pub['Publication Date'] = $date1 . " " . $month[substr($date2, 0, 2)] . " " . substr($date2, 3, 2);

  496.             }

  497.             if (!preg_match('/\s+/', $place)) {

  498.               $pub['Published Location'] = $place;

  499.             }

  500.             if (!preg_match('/\s+/', $lang)) {

  501.               $pub['Language Abbr'] = $lang;

  502.             }

  503.             break;

  504.         default:  // unhandled tag

  505.           break;

  506.       }

  507.     }

  508.     elseif ($xml->nodeType == XMLReader::ELEMENT and $element == 'datafield') {

  509.       $tag  = $xml->getAttribute('tag');

  510.       $ind1 = $xml->getAttribute('ind1');

  511.       $ind2 = $xml->getAttribute('ind2');

  512.       switch ($tag) {

  513.         case '16':  // National Bibliographic Agency Control Number

  514.           break;

  515.         case '35':  // System Control Number

  516.           $author = array();

  517.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  518.           foreach ($codes as $code => $value) {

  519.             switch ($code) {

  520.               case 'a': // System control number

  521.                 $pub['Publication Accession'] = $value;

  522.                 break;

  523.             }

  524.           }

  525.         case '40':  // Cataloging Source (NR)

  526.           $author = array();

  527.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  528.           foreach ($codes as $code => $value) {

  529.             switch ($code) {

  530.               case 'a':  // original cataolging agency

  531.                 $pub['Publication Database'] = $value;

  532.                 break;

  533.             }

  534.           }

  535.           break;

  536.         case '72':  // Subject Category Code

  537.           break;

  538.         case '100':  // main entry-personal name

  539.           $author = tripal_pub_remote_search_AGL_get_author($xml, $ind1);

  540.           $pub['Author List'][] = $author;

  541.           break;

  542.         case '110':  // main entry-corporate nmae

  543.           $author = array();

  544.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  545.           foreach ($codes as $code => $value) {

  546.             switch ($code) {

  547.               case 'a': // Corporate name or jurisdiction name as entry elemen

  548.                 $author['Collective'] = $value;

  549.                 break;

  550.               case 'b': // Subordinate unit

  551.                 $author['Collective'] .= ' ' . $value;

  552.                 break;

  553.             }

  554.           }

  555.           $pub['Author List'][] = $author;

  556.           break;

  557.         case '111':  // main entry-meeting name

  558.           break;

  559.         case '130':  // main entry-uniform title

  560.           break;

  561. 

  562.         case '210':  // abbreviated title

  563.           break;

  564.         case '222':  // key title

  565.           break;

  566.         case '240':  // uniform title

  567.           break;

  568.         case '242':  // translation of title by cataloging agency

  569.           break;

  570.         case '243':  // collective uniform title

  571.           break;

  572.         case '245':  // title statement

  573.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  574.           foreach ($codes as $code => $value) {

  575.             switch ($code) {

  576.               case 'a':

  577.                 $pub['Title'] = trim(preg_replace('/\.$/', '', $value));

  578.                 break;

  579.               case 'b':

  580.                 $pub['Title'] .= ' ' . $value;

  581.                 break;

  582.               case 'h':

  583.                 $pub['Publication Model'] = $value;

  584.                 break;

  585.             }

  586.           }

  587.           break;

  588.         case '246':  // varying form of title

  589.           break;

  590.         case '247':  // former title

  591.           break;

  592. 

  593.         case '250':  // edition statement

  594.           break;

  595.         case '254':  // musicla presentation statement

  596.           break;

  597.         case '255':  // cartographic mathematical data

  598.           break;

  599.         case '256':  // computer file characteristics

  600.           break;

  601.         case '257':  // country of producing entity

  602.           break;

  603.         case '258':  // philatelic issue data

  604.           break;

  605.         case '260':  // publication, distribution ,etc (imprint)

  606.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  607.           foreach ($codes as $code => $value) {

  608.             switch ($code) {

  609.               case 'a':

  610.                 $pub['Published Location'] = $value;

  611.                 break;

  612.               case 'b':

  613.                 $pub['Publisher'] = $value;

  614.                 break;

  615.               case 'c':

  616.                 $pub['Publication Date'] = $value;

  617.                 break;

  618.             }

  619.           }

  620.           break;

  621.         case '263':  // projected publication date

  622.           break;

  623.         case '264':  // production, publication, distribution, manufacture and copyright notice

  624.           break;

  625.         case '270':  // Address

  626.           break;

  627. 

  628.         case '300':  // Address

  629.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  630.           foreach ($codes as $code => $value) {

  631.             switch ($code) {

  632.               case 'a':

  633.                 $pages = $value;

  634.                 $pages = preg_replace('/^p\. /', '', $pages);

  635.                 $pages = preg_replace('/\.$/', '' , $pages);

  636.                 if(preg_match('/p$/', $pages)) {

  637.                   // skip this, it's the number of pages not the page numbers

  638.                 }

  639.                 else {

  640.                   $pub['Pages'] = $pages;

  641.                 }

  642.                 break;

  643.             }

  644.           }

  645.           break;

  646. 

  647. 

  648.         case '500':  // series statements

  649.           $pub['Notes'] = $value;

  650.           break;

  651.         case '504':  // Bibliography, Etc. Note

  652.           break;

  653.         case '520':  // Summary, etc

  654.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  655.           foreach ($codes as $code => $value) {

  656.             switch ($code) {

  657.               case 'a':

  658.                 $pub['Abstract'] = $value;

  659.                 break;

  660.             }

  661.           }

  662.           break;

  663.         case '650':  // Subject Added Entry-Topical Term

  664.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  665.           foreach ($codes as $code => $value) {

  666.             switch ($code) {

  667.               case 'a':

  668.                 $pub['Keywords'][] = $value;

  669.                 break;

  670.             }

  671.           }

  672.           break;

  673.         case '653':  // Index Term-Uncontrolled

  674.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  675.           foreach ($codes as $code => $value) {

  676.             switch ($code) {

  677.               case 'a':

  678.                 $pub['Keywords'][] = $value;

  679.                 break;

  680.             }

  681.           }

  682.           break;

  683.         case '700':  // Added Entry-Personal Name

  684.           $author = tripal_pub_remote_search_AGL_get_author($xml, $ind1);

  685.           $pub['Author List'][] = $author;

  686.           break;

  687.         case '710':  // Added Entry-Corporate Name

  688.           $author = array();

  689.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  690.           foreach ($codes as $code => $value) {

  691.             switch ($code) {

  692.               case 'a': // Corporate name or jurisdiction name as entry elemen

  693.                 $author['Collective'] = $value;

  694.                 break;

  695.               case 'b': // Subordinate unit

  696.                 $author['Collective'] .= ' ' . $value;

  697.                 break;

  698.             }

  699.           }

  700.           $pub['Author List'][] = $author;

  701.           break;

  702.         case '773': // host item entry

  703.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  704.           foreach ($codes as $code => $value) {

  705.             switch ($code) {

  706.             	case 'a':

  707.             		if (preg_match('/Proceedings/i', $value)) {

  708.             		  $pub['Series Name'] = preg_replace('/\.$/', '', $value);

  709.             		  $pub['Publication Type'][0] = 'Conference Proceedings';

  710.             		}

  711.             		else {

  712.             			$pub['Journal Name'] = preg_replace('/\.$/', '', $value);

  713.             		}

  714.                 break;

  715.               case 't':

  716.                 if (preg_match('/Proceedings/i', $value)) {

  717.                   $pub['Series Name'] = preg_replace('/\.$/', '', $value);

  718.                   $pub['Publication Type'][0] = 'Conference Proceedings';

  719.                 }

  720.                 $pub['Journal Name'] = preg_replace('/\.$/', '', $value);

  721.                 break;

  722.               case 'g':

  723.                 $matches = array();

  724.                 if (preg_match('/^(\d\d\d\d)/', $value, $matches)) {

  725.                   $pub['Publication Date'] = $matches[1];

  726.                 }

  727.                 elseif (preg_match('/(.*?)(\.|\s+)\s*(\d+),\s(\d\d\d\d)/', $value, $matches)) {

  728.                   $year = $matches[4];

  729.                   $month = $matches[1];

  730.                   $day = $matches[3];

  731.                   $pub['Publication Date'] = "$year $month $day";

  732.                 }

  733.                 elseif (preg_match('/\((.*?)(\.|\s+)(\d\d\d\d)\)/', $value, $matches)) {

  734.                   $year = $matches[3];

  735.                   $month = $matches[1];

  736.                   $pub['Publication Date'] = "$year $month";

  737.                 }

  738.                 elseif (preg_match('/^(.*?) (\d\d\d\d)/', $value, $matches)) {

  739.                   $year = $matches[2];

  740.                   $month = $matches[1];

  741.                   $pub['Publication Date'] = "$year $month";

  742.                 }

  743.                 if (preg_match('/v\. (.*?)(,|\s+)/', $value, $matches)) {

  744.                   $pub['Volume'] = $matches[1];

  745.                 }

  746.                 if (preg_match('/v\. (.*?)(,|\s+)\((.*?)\)/', $value, $matches)) {

  747.                   $pub['Volume'] = $matches[1];

  748.                   $pub['Issue'] = $matches[3];

  749.                 }

  750.                 if (preg_match('/no\. (.*?)(\s|$)/', $value, $matches)) {

  751.                   $pub['Issue'] = $matches[1];

  752.                 }

  753.                 break;

  754.               case 'p':

  755.                 $pub['Journal Abbreviation'] = $value;

  756.                 break;

  757.               case 'z':

  758.                 $pub['ISBN'] = $value;

  759.                 break;

  760.             }

  761.           }

  762.           break;

  763.         case '852': // Location (Where is the publication held)

  764.           break;

  765.         case '856': // Electronic Location and Access

  766.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  767.           foreach ($codes as $code => $value) {

  768.             switch ($code) {

  769.               case 'u':

  770.                 $pub['URL'] = $value;

  771.                 break;

  772.             }

  773.           }

  774.           break;

  775.         default:

  776.           $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  777.           $unhandled[$tag][] = $codes;

  778.           break;

  779.       }

  780.     }

  781.   }

  782.   //dpm($unhandled);

  783. 

  784.   // build the Dbxref

  785.   if ($pub['Publication Database'] != 'AGL') {

  786. 

  787.   }

  788.   if ($pub['Publication Accession'] and $pub['Publication Database']) {

  789.     $pub['Publication Dbxref'] = $pub['Publication Database'] . ":" . $pub['Publication Accession'];

  790.     unset($pub['Publication Accession']);

  791.     unset($pub['Publication Database']);

  792.   }

  793. 

  794.   // build the full authors list

  795.   if (is_array($pub['Author List'])) {

  796. 	  foreach ($pub['Author List'] as $author) {

  797. 	    if ($author['valid'] == 'N') {

  798. 	      // skip non-valid entries.  A non-valid entry should have

  799. 	      // a corresponding corrected entry so we can saftely skip it.

  800. 	      continue;

  801. 	    }

  802. 	    if ($author['Collective']) {

  803. 	      $authors .= $author['Collective'] . ', ';

  804. 	    }

  805. 	    else {

  806. 	      $authors .= $author['Surname'] . ' ' . $author['First Initials'] . ', ';

  807. 	    }

  808. 	  }

  809. 	  $authors = substr($authors, 0, -2);

  810. 	  $pub['Authors'] = $authors;

  811.   }

  812.   else {

  813.     $pub['Authors'] = $pub['Author List'];	

  814.   }

  815. 

  816.   // build the citation

  817.   $pub['Citation'] = tripal_pub_create_citation($pub);

  818. 

  819.   $pub['raw'] = $pub_xml;

  820.   return $pub;

  821. }

  822. 

  823. /*

  824.  *

  825.  *

  826.  */

  827. function tripal_pub_remote_search_AGL_get_subfield($xml) {

  828.   $codes = array();

  829.   while ($xml->read()) {

  830.     $sub_element = $xml->name;

  831.     // when we've reached the end of the datafield element then break out of the while loop

  832.     if ($xml->nodeType == XMLReader::END_ELEMENT and $sub_element == 'datafield') {

  833.       return $codes;

  834.     }

  835.     // if inside the subfield element then get the code

  836.     if ($xml->nodeType == XMLReader::ELEMENT and $sub_element == 'subfield') {

  837.       $code = $xml->getAttribute('code');

  838.       $xml->read();

  839.       $value = $xml->value;

  840.       $codes[$code] = $value;

  841.     }

  842.   }

  843.   return $codes;

  844. }

  845. 

  846. /*

  847.  *

  848.  *

  849.  */

  850. function tripal_pub_remote_search_AGL_get_author($xml, $ind1) {

  851.   $author = array();

  852.   $codes = tripal_pub_remote_search_AGL_get_subfield($xml);

  853.   foreach ($codes as $code => $value) {

  854.     switch ($code) {

  855.       case 'a':

  856.         // remove any trailing commas

  857.         $value = preg_replace('/,$/', '', $value);

  858.         if ($ind1 == 0) { // Given Name is first

  859.           $author['Given Name'] = $names[0];

  860.         }

  861.         if ($ind1 == 1) { // Surname is first

  862.           // split the parts of the name using a comma

  863.           $names = explode(',', $value);

  864.           $author['Surname'] = $names[0];

  865.           $author['Given Name'] = '';

  866.           unset($names[0]);

  867.           foreach($names as $index => $name) {

  868.             $author['Given Name'] .= $name . ' ';

  869.           }

  870.           $first_names = explode(' ', $author['Given Name']);

  871.           $author['First Initials'] = '';

  872.           foreach ($first_names as $index => $name) {

  873.             $author['First Initials'] .= substr($name, 0, 1);

  874.           }

  875.         }

  876.         if ($ind1 == 3) { // A family name

  877. 

  878.         }

  879.         break;

  880.     }

  881.   }

  882.   return $author;

  883. }