Login   Register  
PHP Classes
elePHPant
Icontem

File: src/unreal4u/rutverifier.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Camilo Sperberg  >  PHP Valida RUT  >  src/unreal4u/rutverifier.php  >  Download  
File: src/unreal4u/rutverifier.php
Role: Class source
Content type: text/plain
Description: Class source
Class: PHP Valida RUT
Validate RUT Chilean numbers
Author: By
Last change: Version 2.2.1 release
JavaScript is now loaded from another repository

Also updated composer.json with this new repository
Code cleanup
Better documentation and version update

PHP now gets the file from the minified javascript version of the
library
Further code simplification

Enabled strict mode on PHPUnit
Added a test case
Small corrections to improve codebase in general
Version 2.0.0

- Removed c_javascript function
- Standarized data type on return for all functions, no more mixed types
- Updated PHPUnit dependency to latest stable version
- Will now test PHP 5.3 in Travis-CI as well
- Class will now sprintf into the error array in preparation for later
i18n implementation
Date: 6 months ago
Size: 8,468 bytes
 

Contents

Class file image Download
<?php
/**
 * Main class that defines the rutverifier class
 *
 * @author unreal4u
 * @link https://github.com/unreal4u/rutverifier
 */

namespace unreal4u;

/**
 * Chilean RUT or RUN verifier
 *
 * <p>A chilean RUT/RUN is any number between 1.000.000 and 99.999.999, where the first 50 million are reserved for
 * normal persons (RUN - Rol ├║nico nacional), and the last 50 millions are reserved for enterprise usage (RUT - Rol
 * ├║nico tributario). This number has also a basic verifier that is the last digit in the following secuence:<br />
 * 12.345.678-9<br />
 * So, the above example corresponds to a natural person, with run number 12.345.678 and verifier 9.</p>
 *
 * <p>This class can be used to check whether a RUT or RUN is a valid one, filtering some common invalid RUTs/RUNs out
 * and with the option to add more to this blacklist. Additionally, it is also capable of delivering a basic JavaScript
 * version which will return true or false depending on the RUT/RUN being valid or not. However, this JavaScript version
 * does not check blacklist and other more advanced stuff.</p>
 *
 * @author Camilo Sperberg
 * @copyright 2010 - 2013 Camilo Sperberg
 * @version 2.2.1
 * @license BSD License
 * @package rutverifier
 */
class rutverifier extends javascriptLoader {

    
/**
     * The version of this class
     * @var string
     */
    
private $classVersion '2.2.1';

    
/**
     * Stores errors of the class
     * @var array
     */
    
public $errors = array();

    
/**
     * Indicates whether we have errors or not
     * @var boolean
     */
    
private $error false;

    
/**
     * Blacklist of all those invalid RUTs
     * @var array
     */
    
private $blacklist = array(
        
'111111111',
        
'222222222',
        
'333333333',
        
'444444444',
        
'555555555',
        
'666666666',
        
'777777777',
        
'888888888',
        
'999999999',
    );

    
/**
     * Prints version information of this class
     * @return string
     */
    
public function __toString() {
        return 
basename(__FILE__).' v'.$this->classVersion.' by Camilo Sperberg - http://unreal4u.com/';
    }

    
/**
     * This function logs all errors the object generates
     *
     * @param int $type Type of error
     * @param string $msg Error message
     * @return boolean Returns always true
     */
    
private function _logError($type$msg='') {
        if (!empty(
$type)) {
            
$typeString '';
            switch (
$type) {
                case 
1:
                    
$typeString 'ERR';
                    
$this->error true;
                break;
                case 
2:
                    
$typeString 'WAR';
                break;
            }

            
$this->errors[] = array(
                
'type' => $typeString,
                
'msg' => $msg,
            );
        }

        return 
true;
    }

    
/**
     * Allows to add some RUT/RUNs to the blacklist in runtime
     *
     * @param mixed $add List of blacklisted RUT, as an array or a string
     * @return int Returns the number of entries in the blacklist
     */
    
public function addToBlacklist($add) {
        if (!empty(
$add)) {
            if (!
is_array($add)) {
                
$add = array($add);
            }
            foreach (
$add AS $a) {
                
$this->blacklist[] = $a;
            }
        }

        return 
count($this->blacklist);
    }

    
/**
     * Returns the RUT type: whether it is a person or a juridic entity (companies)
     *
     * This class will return the information in spanish: "empresa" means company, "natural" means regular person. These
     * names are the correct ones to refer to in Chili.
     * Important: This function doesn't verify that the RUT/RUN is valid! For that, check $this->isValidRUT
     * @see $this->isValidRUT()
     *
     * @param string $rut The RUT for which we want to know
     * @return array Returns empty array in case of invalid RUT, filled in array with data otherwise
     */
    
public function RUTType($rut='') {
        
$output = array();
        if (!empty(
$rut) && is_string($rut)) {
            
$rut $this->formatRUT($rut);
            if (!empty(
$rut)) {
                
$rut substr($rut0, -1);
                
$output = array(
                    
'n',
                    
'natural',
                );
                if (
$rut 100000000 && $rut 50000000) {
                    
$output = array(
                        
'e',
                        
'empresa',
                    );
                }
            }
        }

        return 
$output;
    }

    
/**
     * Applies a filter to the RUT/RUN and formats it for internal class usage
     *
     * @param string $rut The RUT/RUN we want to format
     * @param boolean $withVerifier Whether we want to print the verifier also. Defaults to true
     * @return string Returns empty string when RUT/RUN is invalid or a non-empty string with the RUT/RUN otherwise
     */
    
public function formatRUT($rut=''$withVerifier=true) {
        
$output '';
        if (!empty(
$rut)) {
            
$tmpRUT preg_replace('/[^0-9K]/i'''$rut);

            if (
strlen($tmpRUT) > 7) {
                
$output str_pad(str_replace('k''K'$tmpRUT), 9'0'STR_PAD_LEFT);
            }

            if (
strlen($output) !== 9) {
                
$this->_logError(1sprintf('RUT/RUN doesn\'t have the required size'));
            } elseif (
$withVerifier === false) {
                
$output substr($output0, -1);
            }
        }

        return 
$output;
    }

    
/**
     * Calculates the verifier for a given RUT/RUN which must be provided without verifier
     *
     * @param string $rut RUT/RUN without verifier
     * @return string Returns empty string RUT/RUN is empty, or the verifier otherwise
     */
    
public function getVerifier($rut='') {
        
$return '';
        if (!empty(
$rut) && is_string($rut)) {
            
$multi 2;
            
$sum 0;
            
$strlenRut strlen($rut);
            for (
$i $strlenRut 1$i >= 0$i--) {
                
$sum += ($rut[$i] * $multi);
                
$multi++;
                if (
$multi == $strlenRut) {
                    
$multi 2;
                }
            }

            
$return = (string)(11 - ($sum 11));
            if (
$sum 11 2) {
                
$return str_replace(array(01), array('0''K'), $sum 11);
            }
        }

        return 
$return;
    }

    
/**
     * This function will check whether the RUT/RUN is effectively valid or not
     *
     * @param string $rut RUT/RUN that will be checked
     * @param boolean $extensiveCheck Whether to also check on blacklist. Defaults to true
     * @param boolean $returnBoolean Whether to return true or false or array with data
     * @return mixed Returns boolean true if RUT/RUN is valid, false otherwise. Returns array with data if selected so
     */
    
public function isValidRUT($rut$extensiveCheck=true$returnBoolean=true) {
        
$isValid false;
        
$output false;

        if (!empty(
$rut)) {
            
$rut $this->formatRUT($ruttrue);
            
$sep = array(
                
'rut' => substr($rut0, -1),
                
'dv'  => substr($rut, -1),
            );
            
$rutType $this->RUTType($rut);

            if (
$rutType !== array()) {
                
$isValid true;
                if (
$this->getVerifier($sep['rut']) != $sep['dv']) {
                    
$this->_logError(2sprintf('RUT/RUN (%s) and verifier (%s) don\'t match'$sep['rut'], $sep['dv']));
                    
$isValid false;
                }

                if (
$isValid === true && $extensiveCheck === true) {
                    if (
in_array($sep['rut'] . $sep['dv'], $this->blacklist)) {
                        
$isValid false;
                        
$this->_logError(2sprintf('The entered RUT/RUN "%s%s" is in blacklist'$sep['rut'], $sep['dv']));
                    }
                }
            } else {
                
$this->_logError(2sprintf('RUT/RUN isn\'t within range of natural person or enterprise'));
            }

            
$output[$rut] = array(
                
'isValid'  => $isValid,
                
'rut'      => $sep['rut'],
                
'verifier' => $sep['dv'],
                
'type'     => $rutType,
            );
        }

        if (
$returnBoolean === true) {
            return 
$isValid;
        }
        return 
$output;
    }
}