custom/code_types.inc.php

   1 <?php
   2 /**
   3  * Library and data structure to manage Code Types and code type lookups.
   4  *
   5  * The data structure is the $code_types array.
   6  * The $code_types array is built from the code_types sql table and provides
   7  * abstraction of diagnosis/billing code types.  This is desirable
   8  * because different countries or fields of practice use different methods for
   9  * coding diagnoses, procedures and supplies.  Fees will not be relevant where
  10  * medical care is socialized.
  11  * <pre>Attributes of the $code_types array are:
  12  *  active   - 1 if this code type is activated
  13  *  id       - the numeric identifier of this code type in the codes table
  14  *  claim    - 1 if this code type is used in claims
  15  *  fee      - 1 if fees are used, else 0
  16  *  mod      - the maximum length of a modifier, 0 if modifiers are not used
  17  *  just     - the code type used for justification, empty if none
  18  *  rel      - 1 if other billing codes may be "related" to this code type
  19  *  nofs     - 1 if this code type should NOT appear in the Fee Sheet
  20  *  diag     - 1 if this code type is for diagnosis
  21  *  proc     - 1 if this code type is a procedure/service
  22  *  label    - label used for code type
  23  *  external - 0 for storing codes in the code table
  24  *             1 for storing codes in external ICD10 Diagnosis tables
  25  *             2 for storing codes in external SNOMED (RF1) Diagnosis tables
  26  *             3 for storing codes in external SNOMED (RF2) Diagnosis tables
  27  *             4 for storing codes in external ICD9 Diagnosis tables
  28  *             5 for storing codes in external ICD9 Procedure/Service tables
  29  *             6 for storing codes in external ICD10 Procedure/Service tables
  30  *             7 for storing codes in external SNOMED Clinical Term tables
  31  *             8 for storing codes in external SNOMED (RF2) Clinical Term tables (for future)
  32  *             9 for storing codes in external SNOMED (RF1) Procedure Term tables
  33  *             10 for storing codes in external SNOMED (RF2) Procedure Term tables (for future)
  34  *  term     - 1 if this code type is used as a clinical term
  35  *  problem  - 1 if this code type is used as a medical problem
  36  *
  37  *  </pre>
  38  *
  39  * Copyright (C) 2006-2010 Rod Roark <rod@sunsetsystems.com>
  40  *
  41  * LICENSE: This program is free software; you can redistribute it and/or
  42  * modify it under the terms of the GNU General Public License
  43  * as published by the Free Software Foundation; either version 2
  44  * of the License, or (at your option) any later version.
  45  * This program is distributed in the hope that it will be useful,
  46  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  48  * GNU General Public License for more details.
  49  * You should have received a copy of the GNU General Public License
  50  * along with this program. If not, see <http://opensource.org/licenses/gpl-license.php>;.
  51  *
  52  * @package OpenEMR
  53  * @author  Rod Roark <rod@sunsetsystems.com>
  54  * @author  Brady Miller <brady@sparmy.com>
  55  * @author  Kevin Yeh <kevin.y@integralemr.com>
  56  * @link    http://www.open-emr.org
  57  */
  58
  59 require_once(dirname(__FILE__)."/../library/csv_like_join.php");
  60
  61 $code_types = array();
  62 $default_search_type = '';
  63 $ctres = sqlStatement("SELECT * FROM code_types WHERE ct_active=1 ORDER BY ct_seq, ct_key");
  64 while ($ctrow = sqlFetchArray($ctres)) {
  65   $code_types[$ctrow['ct_key']] = array(
  66     'active' => $ctrow['ct_active'  ],
  67     'id'   => $ctrow['ct_id'  ],
  68     'fee'  => $ctrow['ct_fee' ],
  69     'mod'  => $ctrow['ct_mod' ],
  70     'just' => $ctrow['ct_just'],
  71     'rel'  => $ctrow['ct_rel' ],
  72     'nofs' => $ctrow['ct_nofs'],
  73     'diag' => $ctrow['ct_diag'],
  74     'mask' => $ctrow['ct_mask'],
  75     'label'=> ( (empty($ctrow['ct_label'])) ? $ctrow['ct_key'] : $ctrow['ct_label'] ),
  76     'external'=> $ctrow['ct_external'],
  77     'claim' => $ctrow['ct_claim'],
  78     'proc' => $ctrow['ct_proc'],
  79     'term' => $ctrow['ct_term'],
  80     'problem'=> $ctrow['ct_problem']
  81   );
  82   if ($default_search_type === '') $default_search_type = $ctrow['ct_key'];
  83 }
  84
  85 /** This array contains metadata describing the arrangement of the external data
  86  *  tables for storing codes.
  87  */
  88 $code_external_tables=array();
  89 define('EXT_COL_CODE','code');
  90 define('EXT_COL_DESCRIPTION','description');
  91 define('EXT_COL_DESCRIPTION_BRIEF','description_brief');
  92 define('EXT_TABLE_NAME','table');
  93 define('EXT_FILTER_CLAUSES','filter_clause');
  94 define('EXT_VERSION_ORDER','filter_version_order');
  95 define('EXT_JOINS','joins');
  96 define('JOIN_TABLE','join');
  97 define('JOIN_FIELDS','fields');
  98 define('DISPLAY_DESCRIPTION',"display_description");
  99
 100 /**
 101  * This is a helper function for defining the metadata that describes the tables
 102  *
 103  * @param type $results             A reference to the global array which stores all the metadata
 104  * @param type $index               The external table ID.  This corresponds to the value in the code_types table in the ct_external column
 105  * @param type $table_name          The name of the table which stores the code informattion (e.g. icd9_dx_code
 106  * @param type $col_code            The name of the column which is the code
 107  * @param type $col_description     The name of the column which is the description
 108  * @param type $col_description_brief The name of the column which is the brief description
 109  * @param type $filter_clauses      An array of clauses to be included in the search "WHERE" clause that limits results
 110  * @param type $version_order       How to choose between different revisions of codes
 111  * @param type $joins               An array which describes additional tables to join as part of a code search.
 112  */
 113 function define_external_table(&$results, $index, $table_name,$col_code, $col_description,$col_description_brief,$filter_clauses=array(),$version_order="",$joins=array(),$display_desc="")
 114 {
 115     $results[$index]=array(EXT_TABLE_NAME=>$table_name,
 116                            EXT_COL_CODE=>$col_code,
 117                            EXT_COL_DESCRIPTION=>$col_description,
 118                            EXT_COL_DESCRIPTION_BRIEF=>$col_description_brief,
 119                            EXT_FILTER_CLAUSES=>$filter_clauses,
 120                            EXT_JOINS=>$joins,
 121                            EXT_VERSION_ORDER=>$version_order,
 122                            DISPLAY_DESCRIPTION=>$display_desc
 123                            );
 124 }
 125 // In order to treat all the code types the same for lookup_code_descriptions, we include metadata for the original codes table
 126 define_external_table($code_external_tables,0,'codes','code','code_text','code_text_short',array(),'id');
 127
 128 // ICD9 External Definitions
 129 define_external_table($code_external_tables,4,'icd9_dx_code','formatted_dx_code','long_desc','short_desc',array("active='1'"),'revision DESC');
 130 define_external_table($code_external_tables,5,'icd9_sg_code','formatted_sg_code','long_desc','short_desc',array("active='1'"),'revision DESC');
 131 //**** End ICD9 External Definitions
 132
 133 // SNOMED Definitions
 134 // For generic SNOMED-CT, there is no need to join with the descriptions table to get a specific description Type
 135
 136 // For generic concepts, use the fully specified description (DescriptionType=3) so we can tell the difference between them.
 137 define_external_table($code_external_tables,7,'sct_descriptions','ConceptId','Term','Term',array("DescriptionStatus=0","DescriptionType=3"),"");
 138
 139
 140 // To determine codes, we need to evaluate data in both the sct_descriptions table, and the sct_concepts table.
 141 // the base join with sct_concepts is the same for all types of SNOMED definitions, so we define the common part here
 142 $SNOMED_joins=array(JOIN_TABLE=>"sct_concepts",JOIN_FIELDS=>array("sct_descriptions.ConceptId=sct_concepts.ConceptId"));
 143
 144 // For disorders, use the preferred term (DescriptionType=1)
 145 define_external_table($code_external_tables,2,'sct_descriptions','ConceptId','Term','Term',array("DescriptionStatus=0","DescriptionType=1"),"",array($SNOMED_joins));
 146 // Add the filter to choose only disorders. This filter happens as part of the join with the sct_concepts table
 147 array_push($code_external_tables[2][EXT_JOINS][0][JOIN_FIELDS],"FullySpecifiedName like '%(disorder)'");
 148
 149 // SNOMED-PR definition
 150 define_external_table($code_external_tables,9,'sct_descriptions','ConceptId','Term','Term',array("DescriptionStatus=0","DescriptionType=1"),"",array($SNOMED_joins));
 151 // Add the filter to choose only procedures. This filter happens as part of the join with the sct_concepts table
 152 array_push($code_external_tables[9][EXT_JOINS][0][JOIN_FIELDS],"FullySpecifiedName like '%(procedure)'");
 153
 154
 155 //**** End SNOMED Definitions
 156
 157 // ICD 10 Definitions
 158 define_external_table($code_external_tables,1,'icd10_dx_order_code','formatted_dx_code','long_desc','short_desc',array("active='1'","valid_for_coding = '1'"),'revision DESC');
 159 define_external_table($code_external_tables,6,'icd10_pcs_order_code','pcs_code','long_desc','short_desc',array("active='1'","valid_for_coding = '1'"),'revision DESC');
 160 //**** End ICD 10 Definitions
 161
 162 /**
 163  * This array stores the external table options. See above for $code_types array
 164  * 'external' attribute  for explanation of the option listings.
 165  * @var array
 166  */
 167 $cd_external_options = array(
 168   '0' => xl('No'),
 169   '4' => xl('ICD9 Diagnosis'),
 170   '5' => xl('ICD9 Procedure/Service'),
 171   '1' => xl('ICD10 Diagnosis'),
 172   '6' => xl('ICD10 Procedure/Service'),
 173   '2' => xl('SNOMED (RF1) Diagnosis'),
 174   '7' => xl('SNOMED (RF1) Clinical Term'),
 175   '9' => xl('SNOMED (RF1) Procedure')
 176 );
 177
 178 /**
 179  * Checks is fee are applicable to any of the code types.
 180  *
 181  * @return boolean
 182  */
 183 function fees_are_used() {
 184  global $code_types;
 185  foreach ($code_types as $value) { if ($value['fee'] && $value['active']) return true; }
 186  return false;
 187 }
 188
 189 /**
 190  * Checks is modifiers are applicable to any of the code types.
 191  * (If a code type is not set to show in the fee sheet, then is ignored)
 192  *
 193  * @param  boolean $fee_sheet Will ignore code types that are not shown in the fee sheet
 194  * @return boolean
 195  */
 196 function modifiers_are_used($fee_sheet=false) {
 197  global $code_types;
 198  foreach ($code_types as $value) {
 199   if ($fee_sheet && !empty($value['nofs'])) continue;
 200   if ($value['mod'] && $value['active']) return true;
 201  }
 202  return false;
 203 }
 204
 205 /**
 206  * Checks if justifiers are applicable to any of the code types.
 207  *
 208  * @return boolean
 209  */
 210 function justifiers_are_used() {
 211  global $code_types;
 212  foreach ($code_types as $value) { if (!empty($value['just']) && $value['active']) return true; }
 213  return false;
 214 }
 215
 216 /**
 217  * Checks is related codes are applicable to any of the code types.
 218  *
 219  * @return boolean
 220  */
 221 function related_codes_are_used() {
 222  global $code_types;
 223  foreach ($code_types as $value) { if ($value['rel'] && $value['active']) return true; }
 224  return false;
 225 }
 226
 227 /**
 228  * Convert a code type id (ct_id) to the key string (ct_key)
 229  *
 230  * @param  integer $id
 231  * @return string
 232  */
 233 function convert_type_id_to_key($id) {
 234  global $code_types;
 235  foreach ($code_types as $key => $value) {
 236   if ($value['id'] == $id) return $key;
 237  }
 238 }
 239
 240 /**
 241  * Return listing of pertinent and active code types.
 242  *
 243  * Function will return listing (ct_key) of pertinent
 244  * active code types, such as diagnosis codes or procedure
 245  * codes in a chosen format. Supported returned formats include
 246  * as 1) an array and as 2) a comma-separated lists that has been
 247  * process by urlencode() in order to place into URL  address safely.
 248  *
 249  * @param  string       $category       category of code types('diagnosis', 'procedure', 'clinical_term', 'active' or 'medical_problem')
 250  * @param  string       $return_format  format or returned code types ('array' or 'csv')
 251  * @return string/array
 252  */
 253 function collect_codetypes($category,$return_format="array") {
 254  global $code_types;
 255
 256  $return = array();
 257
 258  foreach ($code_types as $ct_key => $ct_arr) {
 259   if (!$ct_arr['active']) continue;
 260
 261   if ($category == "diagnosis") {
 262    if ($ct_arr['diag']) {
 263     array_push($return,$ct_key);
 264    }
 265   }
 266   else if ($category == "procedure") {
 267    if ($ct_arr['proc']) {
 268     array_push($return,$ct_key);
 269    }
 270   }
 271   else if ($category == "clinical_term") {
 272    if ($ct_arr['term']) {
 273     array_push($return,$ct_key);
 274    }
 275   }
 276   else if ($category == "active") {
 277    if ($ct_arr['active']) {
 278     array_push($return,$ct_key);
 279    }
 280   }
 281   else if ($category == "medical_problem") {
 282    if ($ct_arr['problem']) {
 283     array_push($return,$ct_key);
 284    }
 285   }
 286   else {
 287    //return nothing since no supported category was chosen
 288   }
 289  }
 290
 291  if ($return_format == "csv") {
 292   //return it as a csv string
 293   return csv_like_join($return);
 294  }
 295  else { //$return_format == "array"
 296   //return the array
 297   return $return;
 298  }
 299 }
 300
 301 /**
 302  * Return the code information for a specific code.
 303  *
 304  * Function is able to search a variety of code sets. See the code type items in the comments at top
 305  * of this page for a listing of the code sets supported.
 306  *
 307  * @param  string    $form_code_type  code set key
 308  * @param  string    $code            code
 309  * @param  boolean   $active          if true, then will only return active entries (not pertinent for PROD code sets)
 310  * @return recordset                  will contain only one item (row).
 311  */
 312 function return_code_information($form_code_type,$code,$active=true) {
 313   return code_set_search($form_code_type,$code,false,$active,true);
 314 }
 315
 316 /**
 317 * The main code set searching function.
 318 *
 319 * It will work for searching one or numerous code sets simultaneously.
 320 * Note that when searching numerous code sets, you CAN NOT search the PROD
 321 * codes; the PROD codes can only be searched by itself.
 322 *
 323 * @param string/array  $form_code_type   code set key(s) (can either be one key in a string or multiple/one key(s) in an array
 324 * @param string        $search_term      search term
 325 * @param integer       $limit            Number of results to return (NULL means return all)
 326 * @param string        $category         Category of code sets. This WILL OVERRIDE the $form_code_type setting (category options can be found in the collect_codetypes() function above)
 327 * @param boolean       $active           if true, then will only return active entries
 328 * @param array         $modes            Holds the search modes to process along with the order of processing (if NULL, then default behavior is sequential code then description search)
 329 * @param boolean       $count            if true, then will only return the number of entries
 330 * @param integer       $start            Query start limit (for pagination) (Note this setting will override the above $limit parameter)
 331 * @param integer       $number           Query number returned (for pagination) (Note this setting will override the above $limit parameter)
 332 * @param array         $filter_elements  Array that contains elements to filter
 333 * @return recordset/integer              Will contain either a integer(if counting) or the results (recordset)
 334 */
 335 function main_code_set_search($form_code_type,$search_term,$limit=NULL,$category=NULL,$active=true,$modes=NULL,$count=false,$start=NULL,$number=NULL,$filter_elements=array()) {
 336
 337   // check for a category
 338   if (!empty($category)) {
 339     $form_code_type = collect_codetypes($category,"array");
 340   }
 341
 342   // do the search
 343   if (!empty($form_code_type)) {
 344     if ( is_array($form_code_type) && (count($form_code_type) > 1) ) {
 345       // run the multiple code set search
 346       return multiple_code_set_search($form_code_type,$search_term,$limit,$modes,$count,$active,$start,$number,$filter_elements);
 347     }
 348     if ( is_array($form_code_type) && (count($form_code_type) == 1) ) {
 349       // prepare the variable (ie. convert the one array item to a string) for the non-multiple code set search
 350       $form_code_type = $form_code_type[0];
 351     }
 352     // run the non-multiple code set search
 353     return sequential_code_set_search($form_code_type,$search_term,$limit,$modes,$count,$active,$start,$number,$filter_elements);
 354   }
 355 }
 356
 357 /**
 358  * Main "internal" code set searching function.
 359  *
 360  * Function is able to search a variety of code sets. See the 'external' items in the comments at top
 361  * of this page for a listing of the code sets supported. Also note that Products (using PROD as code type)
 362  * is also supported. (This function is not meant to be called directly)
 363  *
 364  * @param  string    $form_code_type  code set key (special keywords are PROD) (Note --ALL-- has been deprecated and should be run through the multiple_code_set_search() function instead)
 365  * @param  string    $search_term     search term
 366  * @param  boolean   $count           if true, then will only return the number of entries
 367  * @param  boolean   $active          if true, then will only return active entries (not pertinent for PROD code sets)
 368  * @param  boolean   $return_only_one if true, then will only return one perfect matching item
 369  * @param  integer   $start           Query start limit
 370  * @param  integer   $number          Query number returned
 371  * @param  array     $filter_elements Array that contains elements to filter
 372  * @param  integer   $limit           Number of results to return (NULL means return all); note this is ignored if set $start/number
 373  * @param  array     $mode            'default' mode searches code and description, 'code' mode only searches code, 'description' mode searches description (and separates words); note this is ignored if set $return_only_one to TRUE
 374  * @param  array     $return_query    This is a mode that will only return the query (everything except for the LIMIT is included) (returned as an array to include the query string and binding array)
 375  * @return recordset/integer/array
 376  */
 377 function code_set_search($form_code_type,$search_term="",$count=false,$active=true,$return_only_one=false,$start=NULL,$number=NULL,$filter_elements=array(),$limit=NULL,$mode='default',$return_query=false) {
 378   global $code_types,$code_external_tables;
 379
 380   // Figure out the appropriate limit clause
 381   $limit_query = limit_query_string($limit,$start,$number,$return_only_one);
 382
 383   // build the filter_elements sql code
 384   $query_filter_elements="";
 385   if (!empty($filter_elements)) {
 386    foreach ($filter_elements as $key => $element) {
 387     $query_filter_elements .= " AND codes." . add_escape_custom($key) . "=" . "'" . add_escape_custom($element)  . "' ";
 388    }
 389   }
 390
 391   if ($form_code_type == 'PROD') { // Search for products/drugs
 392    if ($count) {
 393        $query = "SELECT count(dt.drug_id) as count ";
 394    }
 395    else {
 396        $query = "SELECT dt.drug_id, dt.selector, d.name ";
 397    }
 398        $query .= "FROM drug_templates AS dt, drugs AS d WHERE " .
 399                  "( d.name LIKE ? OR " .
 400                  "dt.selector LIKE ? ) " .
 401                  "AND d.drug_id = dt.drug_id " .
 402                  "ORDER BY d.name, dt.selector, dt.drug_id $limit_query";
 403    $res = sqlStatement($query, array("%".$search_term."%", "%".$search_term."%") );
 404   }
 405   else { // Start a codes search
 406       // We are looking up the external table id here.  An "unset" value gets treated as 0(zero) without this test.  This way we can differentiate between "unset" and explicitly zero.
 407       $table_id=isset($code_types[$form_code_type]['external']) ? intval(($code_types[$form_code_type]['external'])) : -9999 ;
 408       if($table_id>=0) // We found a definition for the given code search, so start building the query
 409       {
 410             // Place the common columns variable here since all check codes table
 411             $common_columns=" codes.id, codes.code_type, codes.modifier, codes.units, codes.fee, " .
 412                             "codes.superbill, codes.related_code, codes.taxrates, codes.cyp_factor, " .
 413                             "codes.active, codes.reportable, codes.financial_reporting, ";
 414             $columns .= $common_columns . "'" . add_escape_custom($form_code_type) . "' as code_type_name ";
 415
 416             $active_query = '';
 417             if ($active) {
 418                 // Only filter for active codes.  Only the active column in the joined table
 419                 // is affected by this parameter.  Any filtering as a result of "active" status
 420                 // in the external table itself is always applied. I am implementing the behavior
 421                 // just as was done prior to the refactor
 422                 // - Kevin Yeh
 423                 // If there is no entry in codes sql table, then default to active
 424                 //  (this is reason for including NULL below)
 425                 if ($table_id==0) {
 426                     // Search from default codes table
 427                     $active_query=" AND codes.active = 1 ";
 428                 }
 429                 else {
 430                     // Search from external tables
 431                     $active_query=" AND (codes.active = 1 || codes.active IS NULL) ";
 432                 }
 433             }
 434
 435             // Get/set the basic metadata information
 436             $table_info=$code_external_tables[$table_id];
 437             $table=$table_info[EXT_TABLE_NAME];
 438             $table_dot=$table.".";
 439             $code_col=$table_info[EXT_COL_CODE];
 440             $code_text_col=$table_info[EXT_COL_DESCRIPTION];
 441             $code_text_short_col=$table_info[EXT_COL_DESCRIPTION_BRIEF];
 442             if ($table_id==0) {
 443                 $table_info[EXT_FILTER_CLAUSES]=array("code_type=".$code_types[$form_code_type]['id']); // Add a filter for the code type
 444             }
 445             $code_external = $code_types[$form_code_type]['external'];
 446
 447             // If the description is supposed to come from "joined" table instead of the "main",
 448             // the metadata defines a DISPLAY_DESCRIPTION element, and we use that to build up the query
 449             if($table_info[DISPLAY_DESCRIPTION]!="")
 450             {
 451                 $display_description=$table_info[DISPLAY_DESCRIPTION];
 452                 $display_description_brief=$table_info[DISPLAY_DESCRIPTION];
 453             }
 454             else
 455             {
 456                 $display_description=$table_dot.$code_text_col;
 457                 $display_description_brief=$table_dot.$code_text_short_col;
 458             }
 459             // Ensure the external table exists
 460             $check_table = sqlQuery("SHOW TABLES LIKE '".$table."'");
 461             if ( (empty($check_table)) ) {HelpfulDie("Missing table in code set search:".$table);}
 462
 463             $sql_bind_array = array();
 464             if ($count) {
 465                 // only collecting a count
 466                 $query = "SELECT count(".$table_dot.$code_col . ") as count ";
 467             }
 468             else {
 469                 $query = "SELECT '" . $code_external ."' as code_external, " .
 470                          $table_dot.$code_col . " as code, " .
 471                          $display_description . " as code_text, " .
 472                          $display_description_brief . " as code_text_short, " .
 473                          $columns . " ";
 474             }
 475             if ($table_id==0) {
 476                 // Search from default codes table
 477                 $query .= " FROM ".$table." ";
 478             }
 479             else {
 480                 // Search from external tables
 481                 $query .= " FROM ".$table.
 482                           " LEFT OUTER JOIN `codes` " .
 483                           " ON ".$table_dot.$code_col." = codes.code AND codes.code_type = ? ";
 484                 array_push($sql_bind_array,$code_types[$form_code_type]['id']);
 485             }
 486
 487             foreach($table_info[EXT_JOINS] as $join_info)
 488             {
 489               $join_table=$join_info[JOIN_TABLE];
 490               $check_table = sqlQuery("SHOW TABLES LIKE '".$join_table."'");
 491               if ( (empty($check_table)) ) {HelpfulDie("Missing join table in code set search:".$join_table);}
 492               $query.=" INNER JOIN ". $join_table;
 493               $query.=" ON ";
 494               $not_first=false;
 495               foreach($join_info[JOIN_FIELDS] as $field)
 496               {
 497                   if($not_first)
 498                   {
 499                       $query.=" AND ";
 500                   }
 501                   $query.=$field;
 502                   $not_first=true;
 503               }
 504             }
 505
 506       // Setup the where clause based on MODE
 507       $query.= " WHERE ";
 508       if ($return_only_one) {
 509           $query .= $table_dot.$code_col." = ? ";
 510           array_push($sql_bind_array,$search_term);
 511       }
 512       else if($mode=="code") {
 513           $query.= $table_dot.$code_col." like ? ";
 514           array_push($sql_bind_array,$search_term."%");
 515       }
 516       else if($mode=="description"){
 517           $description_keywords=preg_split("/ /",$search_term,-1,PREG_SPLIT_NO_EMPTY);
 518           $query.="(1=1 ";
 519           foreach($description_keywords as $keyword)
 520           {
 521               $query.= " AND ".$table_dot.$code_text_col." LIKE ? ";
 522               array_push($sql_bind_array,"%".$keyword."%");
 523           }
 524           $query.=")";
 525         }
 526       else { // $mode == "default"
 527         $query .= "(".$table_dot.$code_text_col. " LIKE ? OR ".$table_dot.$code_col. " LIKE ?) ";
 528         array_push($sql_bind_array,"%".$search_term."%","%".$search_term."%");
 529       }
 530       // Done setting up the where clause by mode
 531
 532         // Add the metadata related filter clauses
 533         foreach($table_info[EXT_FILTER_CLAUSES] as $filter_clause)
 534         {
 535             $query.=" AND ";
 536             $dot_location=strpos($filter_clause,".");
 537             if($dot_location!==false) {
 538               // The filter clause already includes a table specifier, so don't add one
 539               $query .=$filter_clause;
 540             }
 541             else {
 542                 $query .=$table_dot.$filter_clause;
 543             }
 544         }
 545
 546         $query .=$active_query . $query_filter_elements;
 547
 548         $query .= " ORDER BY ".$table_dot.$code_col."+0,".$table_dot.$code_col;
 549
 550         if ($return_query) {
 551           // Just returning the actual query without the LIMIT information in it. This
 552           // information can then be used to combine queries of different code types
 553           // via the mysql UNION command. Returning an array to contain the query string
 554           // and the binding parameters.
 555           return array('query'=>$query,'binds'=>$sql_bind_array);
 556         }
 557
 558         $query .= $limit_query;
 559
 560         $res = sqlStatement($query,$sql_bind_array);
 561       }
 562     else
 563     {
 564         HelpfulDie("Code type not active or not defined:".$join_info[JOIN_TABLE]);
 565     }
 566   } // End specific code type search
 567
 568   if (isset($res)) {
 569    if ($count) {
 570     // just return the count
 571     $ret = sqlFetchArray($res);
 572     return $ret['count'];
 573    }
 574    else {
 575     // return the data
 576     return $res;
 577    }
 578   }
 579 }
 580
 581 /**
 582  * Lookup Code Descriptions for one or more billing codes.
 583  *
 584  * Function is able to lookup code descriptions from a variety of code sets. See the 'external'
 585  * items in the comments at top of this page for a listing of the code sets supported.
 586  *
 587  * @param  string $codes  Is of the form "type:code;type:code; etc.".
 588  * @param  string $desc_detail Can choose either the normal description('code_text') or the brief description('code_text_short').
 589  * @return string         Is of the form "description;description; etc.".
 590  */
 591 function lookup_code_descriptions($codes,$desc_detail="code_text") {
 592   global $code_types, $code_external_tables;
 593
 594   // ensure $desc_detail is set properly
 595   if ( ($desc_detail != "code_text") && ($desc_detail != "code_text_short") ) {
 596     $desc_detail="code_text";
 597   }
 598
 599   $code_text = '';
 600   if (!empty($codes)) {
 601     $relcodes = explode(';', $codes);
 602     foreach ($relcodes as $codestring) {
 603       if ($codestring === '') continue;
 604       list($codetype, $code) = explode(':', $codestring);
 605       $table_id=$code_types[$codetype]['external'];
 606       if(isset($code_external_tables[$table_id]))
 607       {
 608         $table_info=$code_external_tables[$table_id];
 609         $table_name=$table_info[EXT_TABLE_NAME];
 610         $code_col=$table_info[EXT_COL_CODE];
 611         $desc_col= $table_info[DISPLAY_DESCRIPTION]=="" ? $table_info[EXT_COL_DESCRIPTION] : $table_info[DISPLAY_DESCRIPTION];
 612         $desc_col_short= $table_info[DISPLAY_DESCRIPTION]=="" ? $table_info[EXT_COL_DESCRIPTION_BRIEF] : $table_info[DISPLAY_DESCRIPTION];
 613         $sqlArray = array();
 614         $sql = "SELECT ".$desc_col." as code_text,".$desc_col_short." as code_text_short FROM ".$table_name;
 615
 616         // include the "JOINS" so that we get the preferred term instead of the FullySpecifiedName when appropriate.
 617         foreach($table_info[EXT_JOINS] as $join_info)
 618         {
 619           $join_table=$join_info[JOIN_TABLE];
 620           $check_table = sqlQuery("SHOW TABLES LIKE '".$join_table."'");
 621           if ( (empty($check_table)) ) {HelpfulDie("Missing join table in code set search:".$join_table);}
 622           $sql.=" INNER JOIN ". $join_table;
 623           $sql.=" ON ";
 624           $not_first=false;
 625           foreach($join_info[JOIN_FIELDS] as $field)
 626           {
 627               if($not_first)
 628               {
 629                   $sql.=" AND ";
 630               }
 631               $sql.=$field;
 632               $not_first=true;
 633           }
 634         }
 635
 636         $sql.=" WHERE ";
 637
 638
 639         // Start building up the WHERE clause
 640
 641         // When using the external codes table, we have to filter by the code_type.  (All the other tables only contain one type)
 642         if ($table_id==0) { $sql .= " code_type = '".add_escape_custom($code_types[$codetype]['id'])."' AND ";   }
 643
 644         // Specify the code in the query.
 645         $sql .= $table_name.".".$code_col."=? ";
 646         array_push($sqlArray,$code);
 647
 648         // We need to include the filter clauses
 649         // For SNOMED and SNOMED-CT this ensures that we get the Preferred Term or the Fully Specified Term as appropriate
 650         // It also prevents returning "inactive" results
 651         foreach($table_info[EXT_FILTER_CLAUSES] as $filter_clause)
 652         {
 653             $sql.= " AND ".$filter_clause;
 654         }
 655         // END building the WHERE CLAUSE
 656
 657
 658         if($table_info[EXT_VERSION_ORDER]){$sql .= " ORDER BY ".$table_info[EXT_VERSION_ORDER];}
 659
 660         $sql .= " LIMIT 1";
 661         $crow = sqlQuery($sql,$sqlArray);
 662         if (!empty($crow[$desc_detail])) {
 663           if ($code_text) $code_text .= '; ';
 664           $code_text .= $crow[$desc_detail];
 665         }
 666       }
 667
 668       else {
 669         //using an external code that is not yet supported, so skip.
 670       }
 671     }
 672   }
 673   return $code_text;
 674 }
 675
 676 /**
 677 * Sequential code set "internal" searching function
 678 *
 679 * Function is basically a wrapper of the code_set_search() function to support
 680 * a optimized searching models. The default mode will:
 681 * Searches codes first; then if no hits, it will then search the descriptions
 682 * (which are separated by each word in the code_set_search() function).
 683 * (This function is not meant to be called directly)
 684 *
 685 * @param string $form_code_type code set key (special keyword is PROD) (Note --ALL-- has been deprecated and should be run through the multiple_code_set_search() function instead)
 686 * @param string $search_term search term
 687 * @param integer $limit Number of results to return (NULL means return all)
 688 * @param array $modes Holds the search modes to process along with the order of processing (default behavior is described in above function comment)
 689 * @param boolean $count if true, then will only return the number of entries
 690 * @param boolean $active if true, then will only return active entries
 691 * @param integer $start Query start limit (for pagination)
 692 * @param integer $number Query number returned (for pagination)
 693 * @param array $filter_elements Array that contains elements to filter
 694 * @param string $is_hit_mode This is a mode that simply returns the name of the mode if results were found
 695 * @return recordset/integer/string
 696 */
 697 function sequential_code_set_search($form_code_type,$search_term,$limit=NULL,$modes=NULL,$count=false,$active=true,$start=NULL,$number=NULL,$filter_elements=array(),$is_hit_mode=false) {
 698   // Set the default behavior that is described in above function comments
 699   if (empty($modes)) {
 700     $modes=array('code','description');
 701   }
 702
 703   // Return the Search Results (loop through each mode in order)
 704   foreach ($modes as $mode) {
 705     $res = code_set_search($form_code_type,$search_term,$count,$active,false,$start,$number,$filter_elements,$limit,$mode);
 706     if ( ($count && $res>0) || (!$count && sqlNumRows($res)>0) ) {
 707       if ($is_hit_mode) {
 708         // just return the mode
 709         return $mode;
 710       }
 711       else {
 712         // returns the count number if count is true or returns the data if count is false
 713         return $res;
 714       }
 715     }
 716   }
 717 }
 718
 719 /**
 720 * Code set searching "internal" function for when searching multiple code sets.
 721 *
 722 * It will also work for one code set search, although not meant for this.
 723 * (This function is not meant to be called directly)
 724 *
 725 * @param array $form_code_types code set keys (will default to checking all active code types if blank)
 726 * @param string $search_term search term
 727 * @param integer $limit Number of results to return (NULL means return all)
 728 * @param array $modes Holds the search modes to process along with the order of processing (default behavior is described in above function comment)
 729 * @param boolean $count if true, then will only return the number of entries
 730 * @param boolean $active if true, then will only return active entries
 731 * @param integer $start Query start limit (for pagination)
 732 * @param integer $number Query number returned (for pagination)
 733 * @param array $filter_elements Array that contains elements to filter
 734 * @return recordset/integer
 735 */
 736 function multiple_code_set_search($form_code_types=array(),$search_term,$limit=NULL,$modes=NULL,$count=false,$active=true,$start=NULL,$number=NULL,$filter_elements=array()) {
 737
 738   if (empty($form_code_types)) {
 739     // Collect the active code types
 740     $form_code_types = collect_codetypes("active","array");
 741   }
 742
 743   if ($count) {
 744     //start the counter
 745     $counter = 0;
 746   }
 747   else {
 748     // Figure out the appropriate limit clause
 749     $limit_query = limit_query_string($limit,$start,$number);
 750
 751     // Prepare the sql bind array
 752     $sql_bind_array = array();
 753
 754     // Start the query string
 755     $query = "SELECT * FROM ((";
 756   }
 757
 758   // Loop through each code type
 759   $flag_first = true;
 760   $flag_hit = false; //ensure there is a hit to avoid trying an empty query
 761   foreach ($form_code_types as $form_code_type) {
 762     // see if there is a hit
 763     $mode_hit = NULL;
 764     // only use the count method here, since it's much more efficient than doing the actual query
 765     $mode_hit = sequential_code_set_search($form_code_type,$search_term,NULL,$modes,true,$active,NULL,NULL,$filter_elements,true);
 766     if ($mode_hit) {
 767       if ($count) {
 768         // count the hits
 769         $count_hits = code_set_search($form_code_type,$search_term,$count,$active,false,NULL,NULL,$filter_elements,NULL,$mode_hit);
 770         // increment the counter
 771         $counter += $count_hits;
 772       }
 773       else {
 774         $flag_hit = true;
 775         // build the query
 776         $return_query = code_set_search($form_code_type,$search_term,$count,$active,false,NULL,NULL,$filter_elements,NULL,$mode_hit,true);
 777         if (!empty($sql_bind_array)) {
 778           $sql_bind_array = array_merge($sql_bind_array,$return_query['binds']);
 779         }
 780         else {
 781           $sql_bind_array = $return_query['binds'];
 782         }
 783         if (!$flag_first) {
 784           $query .= ") UNION ALL (";
 785         }
 786         $query .= $return_query['query'];
 787       }
 788       $flag_first = false;
 789     }
 790   }
 791
 792   if ($count) {
 793     //return the count
 794     return $counter;
 795   }
 796   else {
 797     // Finish the query string
 798     $query .= ")) as atari $limit_query";
 799
 800     // Process and return the query (if there was a hit)
 801     if ($flag_hit) {
 802       return sqlStatement($query,$sql_bind_array);
 803     }
 804   }
 805 }
 806
 807 /**
 808 * Returns the limit to be used in the sql query for code set searches.
 809 *
 810 * @param  integer  $limit            Number of results to return (NULL means return all)
 811 * @param  integer  $start            Query start limit (for pagination)
 812 * @param  integer  $number           Query number returned (for pagination)
 813 * @param  boolean  $return_only_one  if true, then will only return one perfect matching item
 814 * @return recordset/integer
 815 */
 816 function limit_query_string($limit=NULL,$start=NULL,$number=NULL,$return_only_one=false) {
 817   if ( !is_null($start) && !is_null($number) ) {
 818     // For pagination of results
 819     $limit_query = " LIMIT $start, $number ";
 820   }
 821   else if (!is_null($limit)) {
 822     $limit_query = " LIMIT $limit ";
 823   }
 824   else {
 825     // No pagination and no limit
 826     $limit_query = '';
 827   }
 828   if ($return_only_one) {
 829      // Only return one result (this is where only matching for exact code match)
 830      // Note this overrides the above limit settings
 831      $limit_query = " LIMIT 1 ";
 832   }
 833   return $limit_query;
 834 }
 835 ?>