MySQL Handler Class – Update

I noticed that the class had a little mistake that would make it not work properly under PHP4 and a little annoying bug that I had on the select method. If you already had downloaded the class, please download this newer version.

Click here to download the newer version: Download

Advertisements

About mcloide

Making things simpler, just check: http://www.mcloide.com View all posts by mcloide

4 responses to “MySQL Handler Class – Update

  • cristian cudos

    Cristiano I made some modification ( minor details ) that help you to save directly from forms into db.

    I use child class too ( one for each table)

    ———-Start Code mysql.inc.php —————
    <?php
    /*
    —————————————————————————–
    | Mysql Wrapper PHP5 Version |
    —————————————————————————–
    | This class will wrap the basic MySQL functions and SQL functions in a |
    | simple way. |
    | The class is basic a database handler with select, insert, update, delete |
    | and query execute methods. The select has the option of returning the |
    | results in a paginated way. |
    —————————————————————————–
    | Copyright (C) 2008 Cristiano Diniz da Silva |
    | 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 3 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, see . |
    | |
    —————————————————————————–
    | Developed by: Cristiano Diniz da Silva |
    —————————————————————————–
    | Url: https://mcloide.wordpress.com |
    —————————————————————————–
    | UPDATES: |
    —————————————————————————–
    | Last update: 09/25/2008 4:23pm |
    | The Select method was fully revised. |
    —————————————————————————–
    */
    class mysql {

    /** var string */
    public $stmt;
    /** var array */
    public $result;
    /** var integer */
    public $last_insert_id;
    /** var string */
    public $error;
    /** var object */
    protected $handler;
    /** var interger */
    public $page;
    /** var interger */
    public $max_results;
    /** var boolean */
    public $use_pagination;
    /** var array */
    public $pagination_results;
    /** var array */
    public $pagination_nav;
    /** var array */
    public $pagination;
    /** var interger */
    public $number_of_pages;
    /** var string */
    public $navigation_page;
    /** var interger */
    public $number_of_results;
    /** var object */
    public $instance;

    /** var tables used for child clases*/
    public $tables;

    /** var fromPost used for child clases autodedect and fix slash quotes*/
    public $fromPost;

    public function __construct($username,$password,$schema,$server = ‘localhost’){
    try{
    if(!isset($server) || !is_string($server) || strlen($server) error = “Please set the database server.”;
    return false;
    }
    else {
    $server = mysql_escape_string($server);
    }
    if(!isset($username) || !is_string($username) || strlen($username) error = “Please set the database username.”;
    return false;
    }
    else {
    $username = mysql_escape_string($username);
    }
    if(!isset($password) || !is_string($password) || strlen($password) error = “Please set the username password.”;
    return false;
    }
    else {
    $password = mysql_escape_string($password);
    }
    if(!isset($server) || !is_string($schema) || strlen($schema) error = “Please set the database schema.”;
    return false;
    }
    else {
    $server = mysql_escape_string($server);
    }

    $this->fromPost = false;
    $this->stmt = “”;
    $this->result = array();
    $this->last_insert_id = 0;
    $this->error = ”;
    $this->handler = mysql_connect($server,$username,$password);
    if($this->handler) {
    if(!$this->select_db($schema)) {
    $this->error = ‘Unable to select the database. Error: ‘.mysql_error();
    return false;
    }
    }
    else {
    $this->error = ‘Unable to connect to the server. Error: ‘.mysql_error();
    return false;
    }
    $this->page = 0;
    $this->max_results = 10;
    $this->use_pagination = true;
    $this->pagination_results = array();
    $this->pagination_nav = array();
    $this->pagination = array();
    $this->number_of_pages = 0;
    $this->number_of_results = 0;
    $this->navigation_page = $_SERVER[‘PHP_SELF’];

    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace”;
    return false;
    }
    }

    /**
    * select_db
    * Will swicth or set the database to the given schema using the same connection made for the handler
    * @param string $schema
    * @return variable value
    */
    public function select_db($schema) {
    if(isset($schema) && is_string($schema) && strlen($schema) > 0) {
    $schema = mysql_escape_string($schema);
    if(!mysql_select_db($schema)) {
    $this->error = ‘Unable to connect to the given database. Please verify the information and try again. Error:’.mysql_error();
    return false;
    }
    return true;
    }
    }

    /**
    * Method GET
    * Use: $object->variable_name. Ex. $object->pagination;
    * @param string $variable
    * @return variable value
    */
    public function __get($variable) {
    if(isset($this->$variable)) {
    return $this->$variable;
    }
    return false;
    }

    /**
    * Select
    * Full method to construct a select query and return paginated results or full results depending on the object configuration
    * @param array $tables => Required. List of all tables for the select. Example: array(‘table1′,’table2’) or array(“table1 ‘a'”,”table2 ‘b'”)
    * @param array $fields. List of all fields that will be returned in the query. If none given, then it will use * for the select. In case of using
    * identifiers for the tables, then use them in the fields. Example: array(), array(‘field1′,’field2′,’field3’), array(‘a.field1′,’b.field2’)
    * @param boolean $isdistinct. It will add the DISTINCT modifier in the query
    * @param array $where. List of all conditions that will be used in the query. Example: array(‘and field1 = field2’, ‘and (field1 = 1 or field2 = 2)’)
    * @param array $join. List of all join clauses that will be used in the query. For the next arrays use the same logic as used for the fields array.
    * @param array $orderby. List of all order by clauses that will be used in the query
    * @param array $groupby. List of all group by fields that will be used in the query
    */
    final public function select($tables, $fields = array(), $isdistinct = false, $where = array(), $join = array(), $orderby = array(), $groupby = array()){
    try{
    /*
    There are 2 statments at this method. The first is the class statement ($this->stmt) and it will return the results of the query. The second
    one is the $stmt and it is used to calculate the number of results of the query without being limited for pagination. The second statement
    will only be executed in the case of a pagination.
    */
    //$stmt = “SELECT”;
    $this->stmt = “SELECT”;
    if($isdistinct === true) {
    $this->stmt .= ” DISTINCT”;
    }

    //$stmt .= ” COUNT (“;
    //if($isdistinct === true) {
    // $stmt .= ” DISTINCT”;
    //}

    if(is_array($fields) && sizeof($fields) > 0) {
    $fieldsSize = sizeof($fields);
    for($k = 0; $k 0) {
    $this->stmt .= “,”;
    }
    $this->stmt .= ” {$fields[$k]}”;
    }
    }
    else {
    $this->stmt .= ” *”;
    }

    // if(isset($fields[0])) {
    // $stmt .= “{$fields[0]})”; # to optimize the query but does not work so well with all fields
    // }
    // else {
    //$stmt .= ” *)”;
    // }

    $this->stmt .= ” FROM”;
    //$stmt .= ” FROM”;

    if(is_array($tables) && sizeof($tables) > 0) {
    $tablesSize = sizeof($tables);
    for($k = 0; $k 0) {
    $this->stmt .= “,”;
    //$stmt .= “,”;
    }
    $this->stmt .= ” {$tables[$k]}”;
    //$stmt .= ” {$tables[$k]}”;
    }
    }
    else {
    $this->error = ‘You must pass the tables (in array) for this query to be executed.’;
    return false;
    }

    if(is_array($join) && sizeof($join) > 0){
    foreach($join as $key => $xjoin) {
    if(is_array($xjoin) && sizeof($xjoin) > 0) {
    foreach($xjoin as $aKey => $info) {
    $direction = $info[‘dir’];
    if(!in_array(strtoupper($direction),array(‘LEFT’,’RIGHT’))){
    $direction = ” LEFT”;
    }
    $innerOuter = $info[‘io’];
    if(!in_array(strtoupper($innerOuter),array(‘INNER’,’OUTER’))){
    $direction = ” OUTER”;
    }
    $table = $info[‘table’];
    $clause = $info[‘clause’];
    $this->stmt .= ” {$direction} {$innerOuter} JOIN {$table} ON {$clause}”;
    //$stmt .= ” {$direction} {$innerOuter} JOIN {$table} ON {$clause}”;
    }
    }
    }
    }

    if(is_array($where) && sizeof($where) > 0) {
    $this->stmt .= ” WHERE 1 AND (“;
    //$stmt .= ” WHERE 1 AND (“;
    foreach($where as $key => $clause) {
    $this->stmt .= ” {$clause}”;
    //$stmt .= ” {$clause}”;
    }
    $this->stmt .= ” )”;
    //$stmt .= ” )”;
    }

    if(is_array($groupby) && sizeof($groupby) > 0) {
    $groupbysize = sizeof($groupby);
    $this->stmt .= ” GROUP BY”;
    for($k = 0; $k 0) {
    $this->stmt .= “,”;
    }
    $this->stmt .= ” {$groupby[$k]}”;
    }
    }

    if(is_array($orderby) && sizeof($orderby) > 0) {
    $orderbysizeof = sizeof($orderby);
    $this->stmt .= ” ORDER BY”;
    for($k = 0; $k 0) {
    $this->stmt .= “,”;
    }
    $this->stmt .= ” {$orderby[$k]}”;
    }
    }

    if($this->use_pagination) {

    if($stmtCountHandler = mysql_query($this->stmt,$this->handler)) {

    #$result = mysql_fetch_row($stmtCountHandler); # calculating how many rows total the query have for using on the pagination
    list($this->number_of_results) = mysql_num_rows($stmtCountHandler);
    $this->number_of_pages = floor($this->number_of_results / $this->max_results);
    $current_page = ($this->page * $this->max_results);

    $this->stmt .= ” LIMIT {$current_page},{$this->max_results}”; # paginating
    # The query changed, so bring only results from the pagination
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    while($row = mysql_fetch_row($stmtHandler)) {
    $this->result[] = $row;
    }
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error();
    return false;
    }

    # Building navigation
    if($this->number_of_pages == 1) {
    $this->number_of_pages++;
    }
    if($this->page > 0) {
    $this->pagination_nav[] = $this->navigation_page.”?&page=0&rpp={$this->max_results}”;
    $this->prev_page = $this->page – 1;
    $this->pagination_nav[] = $this->navigation_page.”?&page={$this->prev_page}&rpp={$this->max_results}”;
    }
    else {
    $this->pagination_nav[] = “javascript:void(0);”;
    $this->prev_page = 0;
    $this->pagination_nav[] = “javascript:void(0);”;
    }
    for($k = 0; $k number_of_pages; ++$k) {
    if($k == $this->page) {
    $this->pagination_nav[] = “javascript:void(0);”;
    }
    else {
    $this->pagination_nav[] = $this->navigation_page.”?&page={$k}&rpp={$this->max_results}”;
    }
    }
    if(($this->page +1) number_of_pages) {
    $this->next_page = $this->page + 1;
    $this->pagination_nav[] = $this->navigation_page.”?&page={$this->next_page}&rpp={$this->max_results}”;
    $this->pagination_nav[] = $this->navigation_page.”?&page={$this->number_of_pages}&rpp={$this->max_results}”;
    }
    else {
    $this->next_page = $this->number_of_pages;
    $this->pagination_nav[] = “javascript:void(0);”;
    $this->pagination_nav[] = “javascript:void(0);”;
    }

    $this->pagination = array(“pag”=>$this->pagination_nav,”results”=>$this->result);
    return $this->pagination;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error();
    return false;
    }
    }
    else {

    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    while($row = mysql_fetch_assoc($stmtHandler)) {
    $this->result[“results”][] = $row;
    }
    return $this->result;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error();
    return false;
    }

    }
    return false;
    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace”;
    return false;
    }
    }

    /**
    * Query
    * Full method to execute any type of query. In the case of a select it will return the results. In the case of the insert the last insert id. In the case of
    * update and deletes it will return the number of affected rows and in the case of the any other type, it will return true.
    * @param string $stmt. The query string that needs to be executed.
    * @return boolean, interger or array
    */
    final public function query($stmt = “”){
    try{
    if(isset($stmt) && is_string($stmt) && strlen($stmt) > 0) {
    $this->stmt = str_replace(“\r”,””,str_replace(“\n”,””,$stmt));
    }
    if(!isset($this->stmt) || !is_string($this->stmt) || strlen($this->stmt) error = “Please enter a query statement to execute.”;
    return false;
    }
    $this->result = array();
    $query_type = strtoupper(trim(substr($this->stmt,0,6)));

    switch($query_type) {
    case ‘SELECT’:{
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    if(mysql_num_rows($stmtHandler) > 1) {
    while($row = mysql_fetch_row($stmtHandler)) {
    $this->result[] = $row;
    }
    }
    else {
    $this->result = mysql_fetch_row($stmtHandler);
    }
    return $this->result;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error().”:: {$this->stmt}”;
    return false;
    }
    }
    break;
    case ‘INSERT’:{
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    $this->last_insert_id = mysql_insert_id();
    return $this->last_insert_id;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error().”:: {$this->stmt}”;
    return false;
    }
    }
    break;
    case ‘UPDATE’:
    case ‘DELETE’:{
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    return true;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error().”:: {$this->stmt}”;
    return false;
    }
    }
    break;
    case ‘SHOW’:{
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    $result = array();
    while($row=mysql_fetch_row($stmtHandler ))
    $result[] = $row;
    return $result;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error().”:: {$this->stmt}”;
    return false;
    }
    }
    break;
    default:{
    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    return true;
    }
    else {
    $this->error = “Unable to execute query. Please verify your statement. “.mysql_error().”:: {$this->stmt}”;
    return false;
    }
    }
    break;
    }
    return false;
    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace :: {$this->stmt}”;
    return false;
    }
    }

    /**
    * Insert
    * Full method to construct and execute an given insert
    * @param string $table: Table in which the insert will be made
    * @param array $fields_values as key being the field and the actual values as being the values
    * @return interger
    */
    final public function insert($table, $fields_values) {
    try{
    if(!isset($table) || !is_string($table) || strlen($table) error = “Please enter the table that you want to perform the insert.”;
    return false;
    }
    if(!isset($fields_values) || !is_array($fields_values) || sizeof($fields_values) error = “Please enter the fields and values to perform the insert.”;
    return false;
    }

    $this->stmt = “INSERT INTO {$table} (“;
    $counter = 0;
    foreach($fields_values as $field => $value) {
    if($counter > 0) {
    $this->stmt .= “,”;
    }
    $this->stmt .= ” {$field}”;
    $counter++;
    }
    $this->stmt .= “) VALUES (“;
    $counter = 0;
    foreach($fields_values as $field => $value) {
    if($counter > 0) {
    $this->stmt .= “,”;
    }
    if(is_numeric($value)) {
    $this->stmt .= ” {$value}”;
    }
    else {
    $this->stmt .= ” ‘”.$this->mysqlEscape($value).”‘”;
    }
    $counter++;
    }
    $this->stmt .= “)”;
    $result = $this->query();
    return $result;
    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace :: {$this->stmt}”;
    return false;
    }
    }

    /**
    * Update
    * @param string $table: table where the update will be performed
    * @param array $fields_values: fields with the respective values to be updated. The keys of the array will be the fields. Example: array(‘field1’ => ‘value1’);
    * @param array $where: where condition to filter down the row(s) where it will be updated
    * @return interger
    */
    final public function update($table, $fields_values, $where = array()) {
    try{
    if(!isset($table) || !is_string($table) || strlen($table) error = “Please enter the table that you want to perform the update.”;
    return false;
    }
    if(!isset($fields_values) || !is_array($fields_values) || sizeof($fields_values) error = “Please enter the fields and values to perform the update.”;
    return false;
    }
    $this->stmt = “UPDATE {$table} SET “;
    $counter = 0;
    foreach($fields_values as $field => $value) {
    if($counter > 0) {
    $this->stmt .= “,”;
    }
    $this->stmt .= ” {$field} = “;
    if(is_numeric($value)) {
    $this->stmt .= $value;
    }
    else {
    $this->stmt .= “‘”.$this->mysqlEscape($value).”‘”;
    }
    $counter++;
    }
    if(isset($where) && is_array($where) && sizeof($where) > 0) {
    $this->stmt .= ” WHERE 1 AND (“;
    foreach($where as $key => $clause) {
    $this->stmt .= ” {$clause}”;
    }
    $this->stmt .= ” )”;
    }
    $this->stmt;
    $result = $this->query();
    return $result;
    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace :: {$this->stmt}”;
    return false;
    }
    }

    /**
    * Update
    * @param string $table: table where the update will be performed
    * @param array $fields_values: fields with the respective values to be updated. The keys of the array will be the fields. Example: array(‘field1’ => ‘value1’);
    * @param array $where: where condition to filter down the row(s) where it will be updated
    * @return interger
    */

    //Autodetect if update or save a record
    /**
    * saveRecord
    * @param array $values: fields with the respective values to be updated. The keys of the array will be the fields. Example: array(‘field1’ => ‘value1’);
    * @param array $pk: primary key of the table generally autoincrement use for detect if update existing record if it’s in the value and it’s = 0
    * @param array $prefix: prefix of the key of the array . Example values[prefix_fieldname] = value
    * @param array $where: where condition to filter down the row(s) where it will be updated
    * @return interger
    */
    final public function saveRecord($values=array(), $pk=”,$prefix = ”,$where=”){
    //First need to determine if insert one or update
    //if where it’s empty look for value of pk if pk=0 update (use extra where too)
    $update = false;
    $new_id = false;
    //First read table fields and if not exit teh field remove from array
    $qry = “SHOW FIELDS FROM `{$this->tables[0]}`”;
    $result = $this->query($qry);

    if ($result && count($result) > 0 ){
    foreach($values as $key=>$value){
    $delvalue = $key;
    foreach($result as $field)
    if($field[0] == substr($key,strlen($prefix)))
    $delvalue = false;
    if($delvalue !== false)
    unset($values[$key]);
    }
    }

    if(count($values) > 0){
    if($where == ” && $pk != ”){
    foreach($values as $key=>$value)
    if($key == $prefix.$pk && $value > 0){
    $update = true;
    $where = “`$pk`=$value”;
    break;
    }
    }
    elseif ($where != ”)
    $update = true; //and dont care what come at $pk

    //Prepare values if prefix != ”
    $field_values = array();

    foreach($values as $key=>$value){
    if($prefix != ”){
    $field_name = substr($key,strlen($prefix));
    }
    else
    $field_name = $key;

    $field_values[$field_name] = $value;
    }

    if($update){
    //Update
    $new_id = $this->update($this->tables[0], $field_values, array($where));
    }
    else{
    //Insert
    $result = $this->insert($this->tables[0], $field_values);

    if($result !== false){
    $qry = “select last_insert_id()”;
    $result = $this->query($qry);
    $new_id = $result[0];
    }
    else
    $new_id = false;
    }
    }

    return $new_id;
    }

    final public function delete($table, $where = array()) {
    try{
    if(!isset($table) || !is_string($table) || strlen($table) error = “Please enter the table that you want to perform the update.”;
    return false;
    }
    $this->stmt = “DELETE FROM {$table}”;

    if(isset($where) && is_array($where) && sizeof($where) > 0) {
    $this->stmt .= ” WHERE 1 AND (“;
    foreach($where as $key => $clause) {
    $this->stmt .= ” {$clause}”;
    }
    $this->stmt .= ” )”;
    }
    $result = $this->query();
    return $result;
    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace”;
    return false;
    }
    }

    final public function getRecord($table, $item, $value){
    try{
    if(!isset($table) || !is_string($table) || strlen($table) error = “Please enter the table that you want to perform the querry.”;
    return false;
    }
    if(!isset($item) || !is_string($item) || strlen($item) error = “Please enter the column that you want to perform the querry.”;
    return false;
    }
    if(!isset($value)) {
    $this->error = “Please enter the value that you want to perform the querry.”;
    return false;
    }

    $this->stmt = “SELECT * FROM `{$table}`”;
    $this->stmt .= ” WHERE `$item` = “;
    $this->stmt .= (is_numeric($value)) ? $value : “‘”.$value.”‘”;
    $this->stmt .= ” LIMIT 0,1″;

    if($stmtHandler = mysql_query($this->stmt,$this->handler)) {
    $row = mysql_fetch_assoc($stmtHandler);
    }
    else
    $row = array();

    return $row;

    }
    catch(Exception $e) {
    $message = $e->getMessage();
    $code = $e->getCode();
    $trace = $e->getTraceAsString();
    $this->error = “Error: $code :: $message – $trace”;
    return false;
    }
    }
    //Prevend double escape from post
    public function mysqlEscape($input) {
    if (get_magic_quotes_gpc() === 0 && $this->fromPost === TRUE)
    $input = mysql_real_escape_string($input);
    elseif($this->fromPost === FALSE)
    $input = mysql_real_escape_string($input);

    return $input;
    }

    }
    ?>

    ———-End Code mysql.inc.php —————

    —Start generic methos for a table —
    tables = array(“{$tbl_prefix}sessions”);
    $this->pk = “session_id”;
    $this->max_results = $perpage;
    $this->pk = “session_id”;
    }

    //General Show Method
    public function showSessions($where = ”, $order = ” , $pag = false){
    if (!is_array($where))
    $where = ($where != ”) ? array($where) : array();
    if (!is_array($order))
    $order = ($order != ”) ? array($order) : array();
    //We don’t use group by
    $arr_res = $this->select($this->tables, array(), false, $where, array(), $order);
    if($pag)
    $this->pagination = $arr_res[“pag”];
    return $arr_res[“results”];
    }

    //Get Only one Record
    public function getSession($id){
    $result = $this->getRecord($this->tables[0], “session_id”, $id);
    $result[‘session_id’] = (isset($result[‘session_id’])) ? $result[‘session_id’] : 0;
    $result[‘user_id’] = (isset($result[‘user_id’])) ? $result[‘user_id’] : 0;

    return $result;
    }

    //Save/update Record
    //values[‘field’] = value
    public function saveSession($values=array(), $prefix = ”,$where=”){
    $result = false;

    if(count($values) > 0)
    $result = $this->saveRecord($values, $this->pk,$prefix,$where);
    else
    $this->error = “Values array there are empty”;

    return $result;
    }

    public function delSession($id,$where=”){
    if($where!= ”){
    $where_arr = array($where);
    }
    else
    $where_arr = array(“{$this->pk} = {$id}”);

    $result = $this->delete($this->tables[0], $where_arr );
    return $result;
    }
    }
    ?>

    —End generic methos for a table —

  • cristian cudos

    I don’t know if in the previous post the codes goes is not send me an email and i will attach it

  • mcloide

    Cristian the code has fallen under the span box of the site, but I have already recovered. I will analyze the code, see your upgrades and create a new release the class. Thanks for the input.
    By the way, I have tried to contact you by your website contact form, but the validation of the captcha it’s not working correctly with blank spaces and blocking the submission.

    Jo soy Braziliane e non hablo espanol mucho, mas compreendo um pouco (desculpa se a ortografia estiver errada).

  • crisguille

    Sorry for the delay you can contact me by email. Site is out of maintenance

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: