HOME

5h-3LL 1.0
DIR: /srv/http/adent.cz/cmsmadesimple.adent.cz/modules/CompanyDirectory/lib
/srv/http/adent.cz/cmsmadesimple.adent.cz/modules/CompanyDirectory/lib/
Current File : /srv/http/adent.cz/cmsmadesimple.adent.cz/modules/CompanyDirectory/lib/class.cd_ascii_importer.php
<?php
#CMS - CMS Made Simple
#(c)2004-6 by Ted Kulp (ted@cmsmadesimple.org)
#This project's homepage is: http://cmsmadesimple.org
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#$Id$

class cd_ascii_importer
{
  private $_errors;
  private $_delimiter;
  private $_mod;
  private $_do_fielddefs;
  private $_do_fieldvals;
  private $_do_categorydefs;
  private $_do_categoryvals;
  private $_do_latlong_lookup;
  private $_check_duplicate_companies;
  private $_max_records;
  private $_do_hierdefs;
  private $_do_hiervals;
  private $_the_user;

  private $_num_companies;
  private $_num_hier;
  private $_num_categories;
  private $_num_fielddefs;
  private $_num_lines;
  private $_linenum;

  private $_hier_cache;
  private $_fielddef_cache;
  private $_category_cache;

  public function __construct(&$mod,$delimiter = '|')
  {
    $this->_errors = array();

    $this->_do_fielddefs = 0;
    $this->_do_fieldvals = 0;
    $this->_the_user = null;
    
    $this->_do_categorydefs = 0;
    $this->_do_categoryvals = 0;

    $this->_do_hierdefs = 0;
    $this->_do_hiervals = 0;

    $this->_do_latlong_lookup = 0;
    $this->_check_duplicate_companies = 0;
    $this->_mod =& $mod;
    $this->_delimiter = $delimiter;
    $this->_max_records = 0;

    $this->_num_companies = 0;
    $this->_num_categories = 0;
    $this->_num_fielddefs = 0;
    $this->_num_hier = 0;
    $this->_num_lines = 0;
  }

  public function get_results()
  {
    return array('num_companies'=>$this->_num_companies,
		 'num_categories'=>$this->_num_categories,
		 'num_fielddefs'=>$this->_num_fielddefs,
		 'num_hier'=>$this->_num_hier,
		 'num_lines'=>$this->_num_lines);
  }

  public function set_user($uid)
  {
    $this->_the_user = $uid;
  }

  public function set_delimiter($char)
  {
    $this->_delimiter = $char;
  }

  public function set_max_companies($num)
  {
    $this->_max_records = $num;
  }

  public function do_fielddefs($flag = true)
  {
    $this->_do_fielddefs = $flag;
  }

  public function do_fieldvals($flag = true)
  {
    $this->_do_fieldvals = $flag;
  }

  public function do_categorydefs($flag = true)
  {
    $this->_do_categorydefs = $flag;
  }

  public function do_categoryvals($flag = true)
  {
    $this->_do_categoryvals = $flag;
  }

  public function do_latlong_lookup($flag = true )
  {
    $this->_do_latlong_lookup = $flag;
  }

  public function check_duplicate_companies($flag = true)
  {
    $this->_check_duplicate_companies = $flag;
  }

  public function do_hierarchyvals($flag = true)
  {
    $this->_do_hiervals = $flag;
  }

  public function do_hierarchydefs($flag = true)
  {
    $this->_do_hierdefs = $flag;
  }

  protected function set_error($msg)
  {
    $str = $this->_mod->Lang('error_prefix_msg',$this->_linenum,$msg);
    $this->_errors[] = $str;
  }

  public function get_errors()
  {
    return $this->_errors;
  }

  public function clear_errors()
  {
    $this->_errors = array();
  }

  private function smart_explode($str,$delim = ',',$safe_char = '"')
  {
    $out = array();
    $col = '';
    $is_safe = 0;
    for( $i = 0; $i < strlen($str); $i++ )
      {
	switch($str[$i])
	  {
	  case $delim:
	    if( !$is_safe )
	      {
		$out[] = $col;
		$col = '';
	      }
	    break;
	  case $safe_char:
	    $is_safe = !$is_safe;
	    break;

	  default:
	    $col .= $str[$i];
	    break;
	  }
      }

    if( !empty($col) )
      $out[] = $col;

    return $out;
  }

  protected function get_fielddef_id($name)
  {
    global $gCms;
    $db =& $gCms->GetDb();

    if( !is_array($this->_fielddef_cache) )
      {
	$query = 'SELECT id,name FROM '.cms_db_prefix().'module_compdir_fielddefs ORDER BY item_order';
	$tmp = $db->GetArray($query);
	if( is_array($tmp) )
	  {
	    $this->_fielddef_cache = cge_array::to_hash($tmp,'name');
	  }
      }

    if( is_array($this->_fielddef_cache) && isset($this->_fielddef_cache[$name]) )
      {
	return $this->_fielddef_cache[$name]['id'];
      }
    return FALSE;
  }

  
  protected function get_hier_id($long_name,$refresh_cache = false)
  {
    global $gCms;
    $db =& $gCms->GetDb();

    if( !is_array($this->_hier_cache) || $refresh_cache == true )
    {
      $query = 'SELECT * FROM '.cms_db_prefix().'module_compdir_hier ORDER BY hierarchy';
      $tmp = $db->GetArray($query);
      if( is_array($tmp) )
	{
	  $tmp2 = cge_array::to_hash($tmp,'long_name');
	  $this->_hier_cache = $tmp2;
	}
      else
	{
	  return FALSE;
	}
    }

    if( !isset($this->_hier_cache[$long_name]) ) return FALSE;
    return $this->_hier_cache[$long_name]['id'];
  }


  protected function insert_hier($long_name)
  {
    if( empty($long_name) ) return;

    global $gCms;
    $db =& $gCms->GetDb();
    $query = 'INSERT INTO '.cms_db_prefix().'module_compdir_hier
             (name,parent_id,long_name) VALUES (?,?,?)';
    $pos = $this->smart_explode($long_name,' | ');
    $tmp = array();
    $parent = -1;
    for( $i = 0; $i < count($pos); $i++ )
      {
	$tmp[] = $pos[$i];
	$tmp2 = implode(' | ',$tmp);
	$name = trim($pos[$i]);
	$this_id = $this->get_hier_id($tmp2,true);
	if( $this_id === FALSE && $name != '')
	  {
	    // gotta insert it.
	    $dbr = $db->Execute($query,array($name,$parent,$tmp2));
	    $this->_num_hier++;
	  }
	$parent = $this->get_hier_id($tmp2,true);
      }
  }


  protected function get_category_id($name)
  {
    global $gCms;
    $db =& $gCms->GetDb();

    if( !is_array($this->_category_cache) )
      {
	$query = 'SELECT id,name FROM '.cms_db_prefix().'module_compdir_categories';
	$tmp = $db->GetArray($query);
	if( is_array($tmp) )
	  {
	    $this->_category_cache = cge_array::to_hash($tmp,'name');
	  }
      }

    if( is_array($this->_category_cache) && isset($this->_category_cache[$name]) )
      {
	return $this->_category_cache[$name]['id'];
      }
    return FALSE;
  }


  private function unprocess_data($data)
  {
    // strip quotes
    $data = trim($data,'"');
    
    // newlines
    $data = str_replace("^^","\n",$data);
    $data = str_replace("-%%-",$this->_delimiter,$data);
    
    return $data;
  }


  private function process_fielddef($line,$rule)
  {
    global $gCms;
    $db =& $gCms->GetDb();

    // break the line into fields again
    $fields = $this->smart_explode($line,$this->_delimiter);

    // build a new record
    $record = array();
    $record['dropdown_data'] = '';
    for( $fld = 1; $fld < count($rule['flds']); $fld++ )
      {
	if( !isset($fields[$fld]) ) continue;
	$fname = $rule['flds'][$fld];
	$record[$fname] = $this->unprocess_data($fields[$fld]);
      }

    // check for duplicate
    $tmp = $this->get_fielddef_id($record['name']);
    if( $tmp ) 
      {
	$this->set_error($this->_mod->Lang('error_duplicate_fielddef'));
	return FALSE;
      }

    // insert that record
    $now = $db->DbTimeStamp(time());
    $item_order = $db->GetOne('SELECT max(item_order) + 1 FROM ' . cms_db_prefix() . 'module_compdir_fielddefs');
    $query = "INSERT INTO ".cms_db_prefix()."module_compdir_fielddefs
             (name, type, max_length, admin_only, public, dropdown_data, item_order, create_date, modified_date)
            VALUES (?,?,?,?,?,?,?,$now,$now)";
    $dbr = $db->Execute($query,array($record['name'],$record['type'],$record['max_length'],
				     $record['admin_only'],$record['public'],
				     $record['dropdown_data'],$item_order));

    // trap the error.
    if( !$dbr )
      {
	$this->set_error($this->_mod->Lang('error_insert_fielddef'));
	return FALSE;
      }
    return TRUE;
  }

  
  private function process_hierarchy($line,$rule)
  {
    global $gCms;
    $db =& $gCms->GetDb();
    $fields = explode($this->_delimiter,$line);

    $record = array();
    for( $fld = 1; $fld < count($rule['flds']); $fld++ )
      {
	if( !isset($fields[$fld]) ) continue;
	$fname = $rule['flds'][$fld];
	$record[$fname] = $this->unprocess_data($fields[$fld]);
      }

    // check for duplicate
    $tmp = $this->get_hier_id($record['long_name']);
    if( $tmp )
      {
	$this->set_error($this->_mod->Lang('error_duplicate_hierarchy',$record['long_name']));
	return FALSE;
      }

    // insert the record
    $tmp = $this->insert_hier($record['long_name']);
    if( $tmp )
      {
	$this->set_error($this->_mod->Lang('error_insert_hierarchy',$record['long_name']));
	return FALSE;
      }

    return TRUE;
  }


  private function process_category($line,$rule)
  {
    global $gCms;
    $db =& $gCms->GetDb();

    // break the line into fields again
    $fields = explode($this->_delimiter,$line);

    // build a new record
    $record = array();
    for( $fld = 1; $fld < count($rule['flds']); $fld++ )
      {
	if( !isset($fields[$fld]) ) continue;
	$fname = $rule['flds'][$fld];
	$record[$fname] = $this->unprocess_data($fields[$fld]);
      }

    // check for duplicate
    $tmp = $this->get_category_id($record['name']);
    if( $tmp ) 
      {
	$this->set_error($this->_mod->Lang('error_duplicate_category'));
	return FALSE;
      }
  
    // insert that record
    $now = $db->DbTimeStamp(time());
    $query = "INSERT INTO ".cms_db_prefix()."module_compdir_categories (name,create_date,modified_date)
             VALUES (?,$now,$now)";
    $dbr = $db->Execute($query,array($record['name']));
  
    // trap the error.
    if( !$dbr )
      {
	$this->set_error($this->_mod->Lang('error_insert_category'));
	return FALSE;
      }
    return TRUE;
  }

  
  private function process_company($fields,$rule)
  {
    global $gCms;
    $db =& $gCms->GetDb();
    $userid = $this->_the_user;

    // build a new record
    $record = array();
    $record['contact_email'] = '';
    $record['details'] = '';
    $record['status'] = 'published';
    $record['latitude'] = '';
    $record['longitude'] = '';
    $record['hier_id'] = null;

    $fieldvals = array();
    $categories = array();
    for( $fld = 1; $fld < count($rule['flds']); $fld++ )
      {
	if( !isset($fields[$fld]) ) continue;
	$fname = $rule['flds'][$fld];

	if( startswith($fname,'FIELD:') )
	  {
	    $fieldvals[substr($fname,6)] = $fields[$fld];
	  }
	else if( startswith($fname,'CAT:') )
	  {
	    $categories[substr($fname,4)] = $fields[$fld];
	  }
	else if( $fname == 'hierarchy' && $this->_do_hiervals)
	  {
	    $tmp = $this->unprocess_data($fields[$fld]);
	    $hier_id = $this->get_hier_id($tmp);
	    if( $hier_id === FALSE && $this->_do_hiervals )
	      {
		$this->insert_hier($tmp);
	      }
	    $hier_id = $this->get_hier_id($tmp);
	    if( $hier_id !== FALSE )
	      $record['hier_id'] = $hier_id;
	  }
	else 
	  {
	    $record[$fname] = $this->unprocess_data($fields[$fld]);
	  }
      }

  
    // data validation
    if( !isset($record['company_name']) || empty($record['company_name']) )
      {
	$this->set_error($mod->Lang('error_import_badvalue','company_name'));
	return FALSE;
      }

    // do optional lat/long lookup
    $record['latitude'] = '';
    if( $this->_do_latlong_lookup )
      {
	if( empty($record['latitude']) || empty($record['longitude']) && !empty($record['address']) )
	  {
	    if( isset($gCms->modules['CGGoogleMaps']) && isset($gCms->modules['CGGoogleMaps']['object']) )
	      {
		$cggm =& $gCms->modules['CGGoogleMaps']['object'];
		if( $cggm )
		  {
		    $data = $cggm->GetCoordsFromAddress($record['address']);
		    $record['latitude'] = $data['lat'];
		    $record['longitude'] = $data['lon'];
		  }
	      }
	  }
      }

    // check for duplicate?
    if( $this->_check_duplicate_companies )
      {
	$query = 'SELECT id FROM '.cms_db_prefix().'module_compdir_companies WHERE company_name = ?';
	$tmp = $db->GetOne($query,array($record['company_name']));
	if( $tmp ) 
	  {
	    $this->set_error($this->_mod->Lang('error_duplicate_company',$record['company_name']));
	    return FALSE;
	  }
      }
  
    // insert that record
    $now = $db->DbTimeStamp(time());
    $query =  "INSERT INTO ".cms_db_prefix()."module_compdir_companies 
              (company_name,address,telephone,fax,contact_email,website,details,status,latitude,longitude,
               owner_id, hier_id,create_date, modified_date)
             VALUES (?,?,?,?,?,?,?,?,?,?,?,?,$now,$now)";
    $dbr = $db->Execute($query,array($record['company_name'],$record['address'],
				     $record['telephone'],$record['fax'],
				     $record['contact_email'],$record['website'],
				     $record['details'],$record['status'],
				     $record['latitude'],$record['longitude'],
				     $userid,$record['hier_id']));
    if( !$dbr ) {
      $this->set_error($this->_mod->Lang('error_insert_company'));
      return FALSE;
    }
    $company_id = $db->Insert_ID();
    
    // insert fieldvals
    if( count($fieldvals) && $this->_do_fieldvals )
      {
	foreach( $fieldvals as $name => $value )
	  {
	    if( empty($value) ) continue;
	    $fielddef_id = $this->get_fielddef_id($name);
	    if( $fielddef_id === FALSE ) continue;
	  
	    $query = 'INSERT INTO '.cms_db_prefix()."module_compdir_fieldvals 
                     (company_id, fielddef_id, value, create_date, modified_date)
                    VALUES (?,?,?,$now,$now)";
	    $dbr = $db->Execute($query,array($company_id,$fielddef_id,$value));
	  }
      }

    // insert categories
    if( count($categories) && $this->_do_categoryvals )
      {
	foreach($categories as $name => $value )
	  {
	    if( $value == 0 ) continue;
	    $category_id = $this->get_category_id($name);
	    if( $category_id === FALSE ) continue;

	    $query = 'INSERT INTO '.cms_db_prefix()."module_compdir_company_categories
                     (company_id,category_id,create_date,modified_date)
                    VALUES (?,?,$now,$now)";
	    $db->Execute($query,array($company_id,$category_id));
	  }
      }

    return TRUE;
  }

  
  public function import_file($filename)
  {
    $this->_linenum = 0;

    $fh = fopen($filename,'r');
    if( !$fh )
      {
	$this->set_error($this->_mod->Lang('error_badupload'));
	return FALSE;
      }
    while( !feof($fh) )
      {
	$line = fgets($fh);
	$this->_linenum++;

	// strip off extra whitespace
	$line = trim($line);

	// skip empty lines
	if ($line == '') {
	  continue;
	}

	//
	// handle definition lines
	//
	$fields = $this->smart_explode($line,$this->_delimiter);
	if(startswith($fields[0],'#COMPANY'))
	  {
	    // company rule
	    if( isset($rules['company']) )
	      {
		// this is bad.
		$this->set_error($this->_mod->Lang('error_import_duplicaterule','COMPANY',$this->_linenum));
		continue;
	      }
	    $tmp = explode('=',$fields[0],2);
	    $identifier = $tmp[1];

	    $rules['company'] = array();
	    $rules['company']['rule'] = $line;
	    $rules['company']['identifier'] = $identifier;
	    $rules['company']['flds'] = $fields;
	    continue;
	  }
	else if( startswith($fields[0],'#FIELDDEF'))
	  {
	    // fielddef rule
	    if( isset($rules['fielddef']) )
	      {
		// this is bad.
		$this->set_error($this->_mod->Lang('error_import_duplicaterule','FIELDDEF',$this->_linenum));
		continue;
	      }

	    $tmp = explode('=',$fields[0],2);
	    $identifier = $tmp[1];

	    $rules['fielddef'] = array();
	    $rules['fielddef']['rule'] = $line;
	    $rules['fielddef']['identifier'] = $identifier;
	    $rules['fielddef']['flds'] = $fields;
	    continue;
	    // fielddef rule
	  }
	else if( startswith($fields[0],'#CATEGORY'))
	  {
	    // category rule
	    if( isset($rules['category']) )
	      {
		// this is bad.
		$this->set_error($this->_mod->Lang('error_import_duplicaterule','CATEGORY',$this->_linenum));
		continue;
	      }
	    $tmp = explode('=',$fields[0],2);
	    $identifier = $tmp[1];

	    $rules['category'] = array();
	    $rules['category']['rule'] = $line;
	    $rules['category']['identifier'] = $identifier;
	    $rules['category']['flds'] = $fields;
	    continue;
	    // category rule.
	  }
	else if( startswith($fields[0],'#HIERARCHY'))
	  {
	    // hierarchy rule
	    if( isset($rules['hierarchy']) )
	      {
		// this is bad.
		$this->set_error($this->_mod->Lang('error_import_duplicaterule','HIERARCHY',$this->_linenum));
		continue;
	      }
	    $tmp = explode('=',$fields[0],2);
	    $identifier = $tmp[1];

	    $rules['hierarchy'] = array();
	    $rules['hierarchy']['rule'] = $line;
	    $rules['hierarchy']['identifier'] = $identifier;
	    $rules['hierarchy']['flds'] = $fields;
	    continue;
	    // hierarchy rule.
	  }
	else if( startswith($line,'#') )
	  {
	    // don't know this one.
	    $this->set_error($this->_mod->Lang('error_import_unknownrule',$this->_linenum));
	    continue;
	  }

	//
	// do real importing
	//
	$rowtype = '';
	foreach( $rules as $name => $data )
	  {
	    if( $fields[0] == $rules[$name]['identifier'] )
	      {
		$rowtype = $name;
		break;
	      }
	  }
	if( empty($rowtype) )
	  {
	    $this->set_error($this->_mod->Lang('error_import_unknownrow',$this->_linenum,$fields[0]));
	    continue;
	  }

	$ret = '';
	switch( $rowtype )
	  {
	  case 'company':
	    if( ($this->_max_records > 0 && $this->_num_companies < $this->_max_records)
		|| $this->_max_records == 0 )
	      {
		$ret = $this->process_company($fields,$rules['company']);
		if( $ret === TRUE )
		  {
		    $this->_num_companies++;
		  }
	      }
	    continue;
	    break;

	  case 'category':
	    if( $this->_do_categorydefs )
	      {
		$ret = $this->process_category($line,$rules['category']);
		if( $ret === TRUE )
		  {
		    $this->_num_categories++;
		  }
	      }
	    continue;
	    break;

	  case 'fielddef':
	    if( $this->_do_fielddefs )
	      {
		$ret = $this->process_fielddef($line,$rules['fielddef']);
		if( $ret === TRUE )
		  {
		    $this->_num_fielddefs++;
		  }
	      }
	    continue;
	    break;

	  case 'hierarchy':
	    if( $this->_do_hierdefs )
	      {
		$ret = $this->process_hierarchy($line,$rules['hierarchy']);
		if( $ret === TRUE )
		  {
		    $this->_num_hier++;
		  }
	      }
	    continue;
	    break;

	  default:
	    $this->set_error($this->_mod->Lang('error_import_unknownrow',$this->_linenum,$fields[0]));
	    continue;
	    break;
	  }
      }
    $this->_num_lines = $this->_linenum;
    return TRUE;
  }

}

#
# EOF
#
?>