Ir para o conteúdo

Gremio10

Cadastrado: 18 Out 2010
Offline Última atividade: Set 30 2015 10:42
*****

#735 Contar Linhas De Um Txt

Postado por Gremio10 em 26 janeiro 2012 - 21:18

To começando a aprender Ruby e gostaria de postar um codigo que eu fiz, já que na internet eu não encontrei.

count = 0

txt = File.readlines( "seuTxt.txt" )

txt.each do |t|
    count += 1
end

puts count



#440 Upload De Arquivos Avançado

Postado por Gremio10 em 26 julho 2011 - 23:40

Então, essa nova versão que fiz possui determinação de extensões que podem ser enviadas, e o limite no tamanho dos arquivos...

espero que gostem :D

<?php
/**
 * Classe para upload de arquivos
 *
 * feita para a manipulação mais eficiente
 * de tipos de arquivos
 * determinação de tamanho máximo
 *
 * @author Felipe Pieretti Umpierre
 * felipeumpierre<at>hotmail<dot>com
 */
class Upload {

    /**
    * PRIVATE
    */
    private $file = array();

    /**
    * PUBLIC
    */
    public $dir = "", $extension, $size;

    /**
    * Prepara os dados do $_FILES para uma variavel.
    * 
    * @param Array $_file
    */
    public function  __construct( $_file )
    {
        foreach( $_FILES[ $_file ] as $key => $values ){
            $this->file[ $key ] = $values;
        }

    }

    /**
    * Faz o upload do arquivo
    */
    public function makeUpload( )
    {
        /**
         * Caso a variável dir, estiver vazia, ele retorna um erro
         */
        if( $this->dir == "" )
        {
            print( "Você deve determinar um caminho para os arquivos." );
            exit;
	}

	if( self::isFile() )
        {
            if( self::size( $this->size ) )
            {
                if( self::isArray( $this->file[ "error" ] ) )
                {
                    try
                    {
                        foreach( $this->file[ "error" ] as $key => $error )
                        {
                            if( $error == UPLOAD_ERR_OK )
                            {
                                /**
                                 * Inicia a cópia do arquivo
                                 */
				$newFileName = date( "dmYHis" ) . "_" . $this->file[ "name" ][ $key ];
				move_uploaded_file( $this->file[ "tmp_name" ][ $key ], $this->dir . $newFileName );
                                /**
                                 * retorna o nome do arquivo, para ser salvo no banco
                                 */
				return $newFileName;
                            }
			}
                    }
                    catch( Exception $ex )
                    {
                        echo $ex->getMessage();
                    }
		}
                else
                {
                    try
                    {
                        /**
                         * Inicia a cópia do arquivo
                         */
			$newFileName = date( "dmYHis" ) . "_" . $this->file[ "name" ];
			move_uploaded_file( $this->file[ "tmp_name" ], $this->dir . $newFileName );
                        /**
                        * retorna o nome do arquivo, para ser salvo no banco
                        */
			return $newFileName;
                    }
                    catch( Exception $ex )
                    {
                        echo $ex->getMessage();
                    }
		}

                header( "Location: index.html" );
            }
            else
            {
		print( "O(s) arquivo(s) é(são) acima do tamanho pré-determinado." );
            }
	}
        else
        {
            print( "O(s) arquivo(s) escolhido(s) não é(são) permitido(s)." );
	}
    }

    /**
    * Verifica se o arquivo é do tamanho determinado pelo programador.
    *
    * @param int $_max_size
    * @return Bool
    */
    private function size( $_max_size )
    {
	$_max_size = self::convertMbToBt( $_max_size );

        if( $this->isFile() )
        {
            if( self::isArray( $this->file[ "size" ] ) )
            {
                $count = count( $this->file[ "size" ] );
		$counter = 0;

		foreach( $this->file[ "size" ] as $newSize )
                {
                    ( $newSize <= $_max_size ) ? $counter++ : $counter-- ;
		}

                return ( $counter == $count ) ? true : false ;
            }
            else
            {
		return ( $this->file[ "size" ] <= $_max_size ) ? true : false ;
            }
        }
    }

    /**
    * Verifica se o arquivo enviado é de uma das extensões permitidas.
    *
    * @return Bool
    */
    private function isFile()
    {
        if( self::isArray( $this->extension ) )
        {
            $extensions = implode( "|", $this->extension );

            $_file_test	= self::isArrayEmpty( $this->file[ "name" ] );

            if( self::isArray( $_file_test ) )
            {
                $count = count( $_file_test );
                $counter = 0;

                foreach( $_file_test as $values )
                {
                    ( preg_match( "/.+\.({$extensions})/", $values ) ) ? $counter++ : $counter-- ;
                }
                
                return ( $count == $counter ) ? true : false ;
            }
            else
            {
                return ( preg_match( "/.+\.({$extensions})/", $_file_test ) ) ? true : false ;
            }

        }
    }

    /**
    * Verifica se existe algum campo vazio.
    *
    * @params Array $_array array de uma key do $_FILES
    * @return Array
    */
    private function isArrayEmpty( $_array )
    {
        if( is_array( $_array ) )
        {
            $_array_search = array_search( "", $_array );

            if( is_numeric( $_array_search ) )
		unset( $_array[ $_array_search ] );
        }

            return $_array;
    }

    /**
    * Verifica se é array.
    *
    * @params Array $_array array de uma key do $_FILES
    * @return Bool
    */
    private function isArray( $_array )
    {
        return ( is_array( $_array ) ) ? true : false ;
    }

    /**
    * Transforma o valor em MB para Byte
    *
    * @params int $_size valor em MB do tamanho máximo
    * @return int
    */
    private function convertMbToBt( $_size )
    {
    	return $_size * pow( 2, 1024 );
    }

}
?>

Para testar :

<?php
require_once "class.upload.php";

/**
* 'file' é o name da input file
*/
$_upload = new Upload( "file" );

$_upload->dir = "upload/";

/**
* sempre tem de ser array, mesmo ser for apenas um valor
*/
$_upload->extension = array( "jpg", "png", "gif", "jpeg", "ico", "bmp" );

/**
* colocar em MB
*/
$_upload->size = 10;

/**
* Pode-se fazer de duas maneiras...
*/

$_upload->makeUpload();

/**
* ou
*/

$_nameFile = $_upload->makeUpload();

/**
* Assim tu possui o nome do(s) arquivos(s)
*/
?>



#404 Paginação Simples

Postado por Gremio10 em 21 fevereiro 2011 - 12:19

Essa classe é apenas para a criação do < primeira 1 2 3 ultima >

Aceito sugestões para melhorias :D

class.conexao.php

<?php
/**
*       Class Conexao:
*
*       Classe de conexão a banco de Dados MySQL
*
*       @version 1.0
*       @author Felipe Pieretti Umpierre 
*       felipeumpierre<at>hotmail<dot>com
*/
class Conexao{
        
        protected $servidor             = "localhost";
        protected $host                 = "root";
        protected $senha                = "";
        protected $banco                = "";
        
        /**
        *       Inicializa a conexão
        */
        public function __construct(){
                
                /**
                * url do site
                */
                $this->root                     = "";
                
                $this->mysqli           = new mysqli($this->servidor,$this->host,$this->senha,$this->banco);
                if($this->mysqli->errno){
                        echo $this->mysqli->error;      
                }
        }
        
        /**
        *       Executa a Query
        *
        *       @params $sql String      - Código SQL
        */
        public function query($sql){
                $this->qry                      = $this->mysqli->query($sql) or die ($this->mysqli->error);
        }
        
        /**
        *       Conta quantos registros foram encontrados
        */
        public function num(){
                return  $this->qry->num_rows;   
        }
        
        /**
        *       Gera um array com o resultado da Query
        */
        public function fetchAll(){
        $data                           = array();
        while($this->reg        = $this->qry->fetch_object()){
                $data[]         = $this->reg;
        }
        return $data;
    }
        
        /**
        *       Retorna um fetch_object da Query
        */
        public function fetchObject(){
                return $this->qry->fetch_object();      
        }
        
        /**
        *       Pega o ultimo Id cadastrado da Query
        */
        public function insertId(){
                return $this->mysqli->insert_id;        
        }
        
}

?>

class.paginator.php

<?php
/**
*	Classe para a Criação de Paginação
*
*	@autor Felipe Pieretti Umpierre
*	felipeumpierre<at>hotmail<dot>com
*	@version 1.0
*/
require("class.conexao.php");

class Paginator extends Conexao{
	
	/**
	*	@params $quant	Int - Quantidade de registros por página
	*	@params $pag	Int	- Página atual, default 0
	*	@params $maximo Int - Máximo de links 
	*	@params $link	String - Link para qual página será apresentado a paginação
	*/
	public $quant;
	public $pag;
	public $maximo;
	public $link;
	
	public function __construct(){
		//$this->initialize	= ($this->pag * $this->quant) - $this->quant;
		parent::__construct();
	}
	
	/**
	*	Cria a paginação e seus links	
	*
	*	@params $sql	String - Query para a paginação
	*	@return	String
	*/
	public function getPaginator($sql){
		
		parent::query($sql);
		$count				= parent::num();
		
		$pags				= ceil($count/$this->quant);
		
		$paginator			= "<a href='{$this->link}?p=1'><< Primeira</a> ";
		
		for($i = ($this->pag - $this->maximo); $i <= ($this->pag - 1); $i++){
			if(!($i <= 0)){
				$paginator 	.= "<a href='{$this->link}?p={$i}'>{$i}</a>";
			}
		}
		
		$paginator 			.= $this->pag." ";
		
		for($i = ($this->pag + 1); $i <= ($this->pag + $this->maximo); $i++) {
			if(!($i > $pags)){
				$paginator	.= " <a href='{$this->link}?p={$i}'>{$i}</a> ";
			}
		}
		
		$paginator			.= "<a href='{$this->link}?p={$pags}'>Última >></a> ";
		
		return $paginator;
	}

}
?>

Testando utilizando o Pesquisa com Array:

$p                      = $_GET["p"];
isset($p)? $p = $p : $p = 1;

$pag->maximo	        = 6;
$pag->pag		= $p;
$pag->quant		= 4;

$initialize		= ($pag->pag * $pag->quant) - $pag->quant;

$pag->link		= "index.php";
$sql			= "SELECT offer.id,offer.offer FROM offer
			   ORDER BY offer.id DESC
			";	
$all = $Sql->findAll("Offer",array("select" => array("offer.id","offer.offer"),"limit" => "{$initialize},{$pag->quant}","order" => "offer.id DESC"));

print_r($pag->getPaginator($sql)); 



#401 Pesquisa Utilizando Array

Postado por Gremio10 em 15 fevereiro 2011 - 14:43

Aqui está a classe que fiz.

Espero que gostem, estou aberto a sugestões para aprimorar mais ela.

Primeiro, minha classe de conexão ao banco...

class.conection.php:

<?php
/**
*	Class Conection:
*
*	Classe de conexão a banco de Dados MySQL
*
* 	@version 1.0
* 	@author Felipe Pieretti Umpierre 
*	felipeumpierre<at>hotmail<dot>com
*/
class Conection{
	
	protected $servidor		= "localhost";
	protected $host			= "root";
	protected $senha		= "";
	protected $banco		= "";
	
	/**
	*	Inicializa a conexão
	*/
	public function __construct(){
		
		/**
		* url do site
		*/
		$this->root			= "";
		
		$this->mysqli		= new mysqli($this->servidor,$this->host,$this->senha,$this->banco);
		if($this->mysqli->errno){
			echo $this->mysqli->error;	
		}
	}
	
	/**
	*	Executa a Query
	*
	*	@params	$sql String	 - Código SQL
	*/
	public function query($sql){
		$this->qry			= $this->mysqli->query($sql) or die ($this->mysqli->error);
	}
	
	/**
	*	Conta quantos registros foram encontrados
	*/
	public function num(){
		return 	$this->qry->num_rows;	
	}
	
	/**
	*	Gera um array com o resultado da Query
	*/
	public function fetchAll(){
        $data 				= array();
        while($this->reg 	= $this->qry->fetch_object()){
                $data[]		= $this->reg;
        }
        return $data;
    }
	
	/**
	*	Retorna um fetch_object da Query
	*/
	public function fetchObject(){
		return $this->qry->fetch_object();	
	}
	
	/**
	*	Pega o ultimo Id cadastrado da Query
	*/
	public function insertId(){
		return $this->mysqli->insert_id;	
	}
	
}

?>

Agora a classe de pesquisa...

class.find.php:

<?php
/**
*	Class Find:
*
*	Classe de pesquisa com array
*
* 	@version 1.0
* 	@author Felipe Pieretti Umpierre 
*	felipeumpierre<at>hotmail<dot>com
*/

require("class.conection.php");

class Find extends Conection{
	
	protected $inner			= "INNER JOIN";
	protected $left				= "LEFT JOIN";
	protected $select			= "SELECT";
	protected $from				= "FROM";
	protected $order			= "ORDER BY";
	protected $limit			= "LIMIT";
	protected $where			= "WHERE";
	protected $group			= "GROUP BY";
	
	/**
	*	Recebe o nome da tabela, e seus parametros para que
	*	possam ser separados para formar a Query
	*
	*	@params $tableName	String 	- nome da tabela
	*	@params $array		Array() - array de parametros
	*	@return String
	*/
	protected function makeQuery($tableName,$array){
		
		$default				= array( "select" 		=> "*","include" 		=> NULL,"conditions" 	=> NULL,"order" 		=> NULL,
										 "limit" 		=> NULL,"offset" 		=> NULL,"foreignkey" 	=> NULL,"habtm" 		=> false,
										 "belongsto" 	=> false,"hasmany" 		=> false,"group" 		=> NULL );
								
		$options				= array_merge($default,$array);
		
		/**
		*	Verifica se cada campo de pesquisa está setado
		*/
		if(isset($options["select"])){
		
			$select				= $options["select"];
			
				if(!is_array($select)){
					$select		= array($options["select"]);
				}			
			$field				= $this->getFields($select,true);
			$sql				= $this->select . $field;
		}
		
		if(!isset($options["from"])){
		
			$from				= array($tableName);
			
			$from 				= $this->getFields($from,true);	
			$sql				.= $this->from .$from;
			
		}		
		
		if(isset($options["joins"])){	
				
			$joins				= $options["joins"];		
			
				if(!is_array($joins)){
					$joins		= array($joins);
				}				
				$count			= count($joins);				
				foreach($joins as $join){
					for($i	= 0; $i <= $count; $i++ ){
						$join[$i]	= "{$this->underscore($join[$i])}";
					}
					$sql		.= $this->inner ." ". $join[0] ." ON (".$join[0].".".$join[1]." = ".$join[2].") \n";
				}
				
		}
		
		if(isset($options["conditions"])){
		
			$conditions			= $options["conditions"];
			
				if(!is_array($conditions)){
					$conditions	= array($conditions);
				}
				foreach($conditions as $condition){
					$cond		.= $condition;		
				}
				$sql			.= $this->where . " " . $cond ."\n";
			
		}
		
		if(isset($options["group"])){
			$group				= $options["group"];
			if(!is_array($group)){
				$group			= array($group);
			}
			$group				= $this->getFields($group,true,true);
			$sql				.= $this->group . " " . $group;
		}
		
		if(isset($options["order"])){
			$order				= $options["order"];
			if(!is_array($order)){
				$order			= array($order);
			}
			$ord				= $this->getFields($order,true,false);
			$sql				.= $this->order . " " .$ord;
		}	
		
		if(isset($options["limit"])){
			$limit				= $options["limit"];
			$sql				.= $this->limit . " " . $limit;
		}		
		return parent::query($sql);
			
	}
	
	/**
	*	Adiciona _ em palavras com letra maiúscula	
	*
	*	@params	$name		String - String a ser transformado
	*	@return String
	*/
	public function underscore($name){
		$name	= preg_replace('/([a-z])([A-Z])/',"$1_$2",$name);	
		$name	= strtr($name," ","_");
		return strtolower($name);
	}
	
	/**
	*	Separa, adiciona ',' e utiliza a função underscore para os parametros de pesquisa
	*
	*	@params	$array		array() - Array do dados
	*	@params $implode 	boolean - Se há o uso do implode ou não
	*	@return	String
	*/
	protected function getFields($array,$implode = false,$underscore = true){
		
		if(is_array($array)){			
			$return				= array();		
			if($underscore){	
				foreach($array as $field){
					$return[] 	= "\n\t{$this->underscore($field)}";			
				}			
			}else{
				foreach($array as $field){
					$return[] 	= "\n\t{$field}";			
				}	
			}
			if($implode){
				$return 		= implode(",",$return) . "\n";
			}				
			return $return;					
		}		

	}
	
	/**
	*	Cria um array com o resultado da pesquisa
	*	
	*	@params $tableName 	String	- nome da tabela
	*	@params	$array		Array()	- array de parametros
	*	@return Array()
	*/
	public function makeArray($tableName,$array){
		$this->makeQuery($tableName,$array);
		return parent::fetchAll();
	}
	
	/**
	*	Cria um objeto com o resultado da pesquisa
	*	
	*	@params $tableName 	String	- nome da tabela
	*	@params	$array		Array()	- array de parametros
	*	@return Object
	*/
	public function makeObject($tableName,$array){
		$this->makeQuery($tableName,$array);
		return parent::fetchObject();
	}
	
	/**
	*	Função para debugar o SQL
	*
	*	@params $txt		String	- Text/SQL a ser exibido
	*/
	public function printr($txt){
		echo "<pre>";
			print_r($txt);
		echo "</pre>";
	}
		
}
?>

Modo de utilizar:

require("class.find.php");

$sql    = new Find;

//$a    = $sql->makeObject(...

$a	= $sql->makeArray("Offer",array(
	"select" => array("offer.offer","offer.id"),
        // joins -> array(array(tabela,campo referente a tabela, e o campo de comparação),...);
	"joins" => array(array("Sold","offerId","offer.id"),array("Information","id","offer.informationId")),
	"conditions" => "offer.id = 7",
	"limit" => 1,
	"group" => "offer.id",
	"order" => array("offer.id DESC","offer.offer ASC")
	));
		
foreach($a as $<img src='http://code.imasters.com.br/public/style_emoticons/default/cool.gif' class='bbc_emoticon' alt='B)' />{
    echo $b->offer;
}




#377 Mysql Para Csv

Postado por Gremio10 em 06 dezembro 2010 - 16:49

Fala galera, continuando com os codigos com CSV, esse com ajuda de codigos da net, criei uma class pra isso.:

Mysql2Csv.class.php
<?php 
require("conection.class.php");

class Mysql2Csv extends Conect{
	private $csv_terminated = "\n";
    private $csv_separator 	= ";";
    private $csv_enclosed 	= '"';
    private $csv_escaped 	= "\r";
	private $sql_query;
	public $query;
	
	public function __construct(){
		parent::__construct();	
		ob_start();
	}
		
	public function mysql2Csv($filename){
		$result 		= mysql_query($this->query) or die (mysql_error());
        $fields_cnt 	= mysql_num_fields($result);
        $schema_insert 	= '';
        for ($i = 0; $i < $fields_cnt; $i++)
        {
                $l = $this->csv_enclosed . str_replace($this->csv_enclosed, $this->csv_escaped . $this->csv_enclosed,
                        stripslashes(mysql_field_name($result, $i))) . $this->csv_enclosed;
                $schema_insert .= $l;
                $schema_insert .= $this->csv_separator;
        }
        $out = trim(substr($schema_insert, 0, -1));
        $out .= $this->csv_terminated;
        
        while ($row = mysql_fetch_array($result))
        {
                $schema_insert = '';
                for ($j = 0; $j < $fields_cnt; $j++)
                {
                        if ($row[$j] == '0' || $row[$j] != '')
                        {
                                if ($this->csv_enclosed == '')
                                {
                                        $schema_insert .= $row[$j];
                                } else
                                {
                                        $schema_insert .= $this->csv_enclosed .
                                        str_replace($this->csv_enclosed, $this->csv_escaped . $this->csv_enclosed, $row[$j]) . $this->csv_enclosed;
                                }
                        } else
                        {
                                $schema_insert .= '';
                        }
                        if ($j < $fields_cnt - 1)
                        {
                                $schema_insert .= $this->csv_separator;
                        }
                }
                $out .= $schema_insert;
                $out .= $this->csv_terminated;
        }
		header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
        header("Content-Length: " . strlen($out));
        header("Content-type: application/csv");
        header("Content-Disposition: attachment; filename=$filename");
        echo $out;
        exit;
	}	
	
	public function sql($array){
		
		$sql = "";
		
	if(is_array($array)){
		
		if($array["keyword"] != ""){
			$sql .= 
			" AND p.name LIKE '%".$array["keyword"]."%' OR rf.reference LIKE '%".$array["keyword"]."%'";
		}
		
		if($array["supplier"] != ""){
			$sql .=
			" AND p.supplier_id = '".$array["supplier"]."' ";	
		}
		
		if($array["category"] != ""){
			$sql .=
			" AND EXISTS (SELECT id FROM category_product WHERE p.id = category_product.product_id AND category_product.category_id = '".$array["category"]."')";
		}
		
	}
		
		$this->query = "SELECT 
								p.name AS Produto,
								rf.reference AS Referencia,
								sp.value AS De,
								sp.promotional_value AS Por,
								sp.delivery_time AS Prazo,
							(
								SELECT ra.value
								FROM  reference_attribute ra
								INNER JOIN attribute at ON (at.id = ra.attribute_id)
								WHERE at.identification = 'product_peso_bruto'
								AND p.id = rf.product_id
								AND rf.id = ra.reference_id
								LIMIT 1
							) AS Peso,
							(
								SELECT ra.value
								FROM  reference_attribute ra
								INNER JOIN attribute at ON (at.id = ra.attribute_id)
								WHERE at.identification = 'product_comprimento'
								AND p.id = rf.product_id
								AND rf.id = ra.reference_id
								LIMIT 1
							) AS Comprimento,
							(
								SELECT ra.value
								FROM  reference_attribute ra
								INNER JOIN attribute at ON (at.id = ra.attribute_id)
								WHERE at.identification = 'product_largura'
								AND p.id = rf.product_id
								AND rf.id = ra.reference_id
								LIMIT 1
							) AS Largura,
							(
								SELECT ra.value
								FROM  reference_attribute ra
								INNER JOIN attribute at ON (at.id = ra.attribute_id)
								WHERE at.identification = 'product_altura'
								AND p.id = rf.product_id
								AND rf.id = ra.reference_id
								LIMIT 1
							) AS Altura,
						CASE WHEN p.has_stock = 1 THEN 'Sim' ELSE 'Não' END as Estoque,
						CASE WHEN p.is_active = 1 THEN 'Sim' ELSE 'Não' END as Ativo
						FROM product p
						INNER JOIN shop_product sp ON (p.id = sp.product_id)
						INNER JOIN reference rf ON (p.id = rf.product_id)
						WHERE 1 = 1 
						".$sql."";
			
	}
		
	public function sqlClientes(){
					$this->query 	= 'SELECT 				
									name,	 
									email,	 
									cpf	 
								FROM user 
								WHERE character_length(trim(replace(replace(replace(cpf,".", ""),"/", ""),"-", ""))) = "14"';
	}
	
	public function __destruct(){
		ob_end_flush();	
	}
}
?>

conection.class.php
<?php
class Conect{
	private $server		= "";
	private $host		= "";
	private $password	= "";
	private $database	= "";
	private $fields;
	
	
	public function __construct(){
		$mysql			= mysql_connect($this->server,$this->host,$this->password) or die (mysql_error());  
						  mysql_select_db($this->database,$mysql) or die (mysql_error());
	}
}
?>

index.php
<?php 
require "class.php";
$mysql2Csv 	= new Mysql2Csv();
$file		= "produtos_" . date("d_m_Y") . ".csv";

	if(isset($_GET["cnpj"]) && ($_GET["cnpj"] == "s" )){
		$mysql2Csv->sqlClientes();
		$mysql2Csv->mysql2Csv($file);
	}else{
		$keyword	= $_POST["searchFilter"]["keyword"];
		$category	= $_POST["searchFilter"]["categoryId"];
		$supplier	= $_POST["searchFilter"]["supplierId"];
		
		$array		= array("keyword" => $keyword, "category" => $category, "supplier" => $supplier);
		
		$mysql2Csv->sql($array);
		$mysql2Csv->mysql2Csv($file);
	} 
?>



#368 Enviar Csv Para Mysql

Postado por Gremio10 em 18 novembro 2010 - 09:54

Fala galera, fiz esse código, em parceria com uma função que rola na net, e queria compartilhar.

class.csv.php

<?php

    define('C_PPCSV_HEADER_RAW',0);
    define('C_PPCSV_HEADER_NICE',1);
   
    class PaperPear_CSVParser
    {
        private $m_saHeader 	= array();
        private $m_sFileName 	= '';
        private $m_fp		= false;
        private $m_naHeaderMap 	= array();
        private $m_saValues 	= array();
       
        function __construct($sFileName)
        {
            //quick and dirty opening and processing.. you may wish to clean this up
            if ($this->m_fp = fopen($sFileName, 'r'))
            {
                $this->processHeader();
            }
        }
   
          function __call($sMethodName, $saArgs)
        {
            //check to see if this is a set() or get() request, and extract the name
            if (preg_match("/[sg]et(.*)/", $sMethodName, $saFound))
            {
                //convert the name portion of the [gs]et to uppercase for header checking
                $sName = strtoupper($saFound[1]);
               
                //see if the entry exists in our named header-> index mapping
                  if (array_key_exists($sName, $this->m_naHeaderMap))
                  {
                      //it does.. so consult the header map for which index this header controls
                      $nIndex = $this->m_naHeaderMap[$sName];
                      if ($sMethodName{0} == 'g')
                      {
                          //return the value stored in the index associated with this name
                             return $this->m_saValues[$nIndex];
                      }
                      else
                      {
                          //set the valuw
                          $this->m_saValues[$nIndex] = $saArgs[0];
                          return true;
                      }
                  }
            }
           
            //nothing we control so bail out with a false
              return false;
          }       
         
          //get a nicely formatted header name. This will take product_id and make
          //it PRODUCTID in the header map. So now you won't need to worry about whether you need
          //to do a getProductID, or getproductid, or getProductId.. all will work.
        public static function GetNiceHeaderName($sName)
        {
            return strtoupper(preg_replace('/[^A-Za-z0-9]/', '', $sName));
        }

        //process the header entry so we can map our named header fields to a numerical index, which
        //we'll use when we use fgetcsv().
        private function processHeader()
        {
            $sLine = fgets($this->m_fp);
                        //you'll want to make this configurable
            $saFields = split(",", $sLine);
           
            $nIndex = 0;
            foreach ($saFields as $sField)
            {
                //get the nice name to use for "get" and "set".
                $sField = trim($sField);
               
                $sNiceName = PaperPear_CSVParser::GetNiceHeaderName($sField);
               
                //track correlation of raw -> nice name so we don't have to do on-the-fly nice name checks
                $this->m_saHeader[$nIndex] = array(C_PPCSV_HEADER_RAW => $sField, C_PPCSV_HEADER_NICE => $sNiceName);
                $this->m_naHeaderMap[$sNiceName] = $nIndex;
                $nIndex++;
            }
        }
       
        //read the next CSV entry
        public function getNext()
        {
            //this is a basic read, you will likely want to change this to accomodate what
            //you are using for CSV parameters (tabs, encapsulation, etc).
            if (($saValues = fgetcsv($this->m_fp)) !== false)
            {
                $this->m_saValues = $saValues;
                return true;
            }
            return false;
        }
    }

?>

class.upload.php

<?php
/**
* Classe para upload de arquivos
*
* @autor Felipe Pieretti Umpierre
* felipeumpierre at hotmail dot com
*/
class Upload{

	/**
	*
	* @param $dir 		String 	- Caminho do upload
	* @param $arquivo 	Array	- Armazena o nome e o nome tmp do arquivo
	* @param $ok		Bool	- Libera ou não o upload
	*/
	var $dir 		= "upload/";	
	var $arquivo	        = array();
	var $ok 		= false;
	
	/**
	*
	* @param $file 		String	- Arquivo que foi colocado a upload
	* @return Bool
	*/
	public function __construct($file){

		$this->arquivo[0] = $_FILES[$file]["name"];
		$this->arquivo[1] = $_FILES[$file]["tmp_name"];
		
		if(Upload::verificaExistencia($this->arquivo[0])){
			if($this->ok != true){
				if(Upload::fazUpload($this->arquivo[1],$this->arquivo[0])){
					$this->ok = true;
				}
			}
		}else{$this->ok = true;}		
	}
	
	/**
	* Verifica se já existe o arquivo na pasta
	* @param $file 		String	- Nome do arquivo
	* @return Bool
	*/
	public function verificaExistencia($file){
		if(!file_exists($this->dir.$file)){
			return true;
		}else{
			return;	
		}
	}
	
	/**
	* Tenta fazer o upload do arquivo
	* @param $f_tmp		String - Nome tmp do arquivo
	* @param $file		String - Nome do arquivo
	* @return Bool
	*/
	public function fazUpload($f_tmp,$file){
		if (move_uploaded_file($f_tmp, $this->dir  . $file)) {
				return true;		
		}else{
				return;
		}
	}	
}
?>


class.conexao.php

<?php

/**
* Classe de conexão com o banco de dados
* utilizando o MySqlI
*
* @author Felipe Pieretti Umpierre
* felipeumpierre at hotmail dot com
*/

class Conexao{
	
	/**
	*
	* @param $mysqli 		- recebe a coneção do banco
	* @param $servidor		- nome do servidor
	* @param $user			- nome do usuario
	* @param $senha			- senha do servidor
	* @param $banco			- nome do banco de dados
	* @param $busca			- recebe a query
	* @param $qnt			- recebe a quantidade de resultados da query
	*/
	public $mysqli;
	protected $servidor 	= "localhost";	
	protected $user			= "root";
	protected $senha		= "";
	protected $banco		= "csv";
	public $busca;
	public $qnt;
	
	public function __construct(){
		$this->mysqli	= new mysqli($this->servidor,$this->user,$this->senha,$this->banco);
		
		if($this->mysqli->errno){
			echo "Erro > " . $this->mysqli->error;	
		}
	}
	
	/**
	* 
	* @param $sql	String	- SQL para a query
	* @return 				- valor retornado da query
	*/
	public function query($sql){
		$this->busca = $this->mysqli->query($sql) or die($this->mysqli->error);
		$this->qnt	= $this->busca->num_rows;
	}
}

?>

upload.php

<?php
	ob_start();
	
	/**
	* Pega as classes
	*/
   	require("class.csv.php");
   	require("class.conexao.php");
	require("class.upload.php");
	
	/**
	* Instancia as classes em objetos
	*/
	$con	 	= new Conexao;  
	$upload  	= new Upload("file");
	$o 		 	= new PaperPear_CSVParser($upload->arquivo[0]);		
	
	/**
	* Verifica se a variavel ok é true
	*/
	if($upload->ok){		
		while ($o->getNext())
		{					
		
			/**
			* Chama a página com os sql's
                        * SQL à escolha
                        * ele retorna as variaveis sempre o nome na primeira linha, exemplo,
                        * digamos que a primeira linha do meu csv é id
                        * vai ficar assim $o->getId() e assim para outros
			*/
			require("sql.php");
			
			/**
			* Faz a query SELECT por cada Id
			*/
			$con->query($sql_verifica);											
			
			/**
			* Verifica se achou algo
			*/
			if($con->qnt == 0){	
				
				/**
				* Caso não tenha achado nada, ele faz um insert de todos os dados
				*/		
				$busca	= $con->query($sql_insere);
			}else{
				
				/**
				* Caso contrário, ele apenas faz um Update
				*/
				$busca	= $con->query($sql_update);	
			}
		}	
		header("Location: index.php");
	}	
?>

index.html

<form action="upload.php" method="post" enctype="multipart/form-data">
<input type="file" name="file"><br />
<input type="submit" name="arq" value="Enviar">
</form>

Espero que gostem ;)


#361 Upload De Arquivos Simples

Postado por Gremio10 em 12 novembro 2010 - 09:51

Eai pessoal, meu primeiro post aqui, espero que vocês gostem, fiz uma classezinha bem simples mas que funciona para upload de arquivos...


class.upload.php
<?php
/**
* Classe para upload de arquivos
*
* @autor Felipe Pieretti Umpierre
* felipeumpierre at hotmail dot com
*/
class Upload{

	/**
	*
	* @param $dir 		String 	- Caminho do upload
	* @param $arquivo 	Array	- Armazena o nome e o nome tmp do arquivo
	* @param $ok		Bool	- Libera ou não o upload
	*/
	var $dir 		= "upload/";	
	var $arquivo	= array();
	var	$ok			= false;
	
	/**
	*
	* @param $file 		String	- Arquivo que foi colocado a upload
	* @return Bool
	*/
	public function __construct($file){

		$this->arquivo[0] = $_FILES[$file]["name"];
		$this->arquivo[1] = $_FILES[$file]["tmp_name"];
		
		if(Upload::verificaExistencia($this->arquivo[0])){
			if($this->ok != true){
				if(Upload::fazUpload($this->arquivo[1],$this->arquivo[0])){
					$this->ok = true;
				}
			}
		}else{$this->ok = true;}		
	}
	
	/**
	* Verifica se já existe o arquivo na pasta
	* @param $file 		String	- Nome do arquivo
	* @return Bool
	*/
	public function verificaExistencia($file){
		if(!file_exists($this->dir.$file)){
			return true;
		}else{
			return;	
		}
	}
	
	/**
	* Tenta fazer o upload do arquivo
	* @param $f_tmp		String - Nome tmp do arquivo
	* @param $file		String - Nome do arquivo
	* @return Bool
	*/
	public function fazUpload($f_tmp,$file){
		if (move_uploaded_file($f_tmp, $this->dir  . $file)) {
				return true;		
		}else{
				return;
		}
	}	
}
?>

Aqui está como utilizar ela:

<?php
	/**
	* Pega a classe
	*/
	require("class.upload.php");
	
	/**
	* Instancia as classes em objetos
	*/
	$upload  	= new Upload("file");
	
	/**
	* Verifica se a variavel ok é true
	*/
	if($upload->ok){		
		echo "Upload feito com sucesso!";	
	}else{
                echo "Erro ao tentar fazer o upload.";
        }
?>