Ir para o conteúdo

Gremio10

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

Códigos que criei

Contar Linhas De Um Txt

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

Upload De Arquivos Avançado

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)
*/
?>

Paginação Simples

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)); 

Pesquisa Utilizando Array

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;
}