/**
* Cria um novo log de acesso
*/
public function novo($sessionid, $ip, $reverso, $navigator)
{
if (empty($sessionid)) {
Factory::log()->info('Sessionid e usuário são vazios');
return 0;
}
return $this->insert(array('sessionid' => $sessionid, 'ip' => $ip, 'ipreverso' => $reverso, 'navigatorso' => $navigator));
}
/**
* Cria um novo resultado de busca
* @param string $termo Termo que foi pesquisado
* @param int $total Quantos resultados foram encontrados ao realizar a busca
* @param string $query Consulta realizada no banco de dados
* @param string $sessionid Hash da sessão do usuário (somente utilizado quando o usuario não estiver logado)
* @param int $usuario Codigo do usuario logado no sistema (se o mesmo estiver logado)
* @return int
*/
public function novo($termo, $total, $query, $sessionid, $usuario = null)
{
if (empty($sessionid)) {
Factory::log()->info('Sessionid e usuário são vazios');
return 0;
}
return $this->insert(array('termo' => $termo, 'totalresultado' => $total, 'query' => $query, 'sessionid' => $sessionid, 'usuario' => $usuario));
}
/**
*
* @param array $params
* @return mixed DAO se a Flag::DAO_NAME for setada ou null caso contrário
*/
public function getDAO($params)
{
$daoname = getValueFromArray($params, Flag::DAO_NAME, "");
if (empty($daoname)) {
Factory::log()->fatal('É necessário informar o nome do DAO... use Flag::DAO_NAME no parameter!');
return null;
}
return Factory::DAO($daoname);
}
protected function _isValid($value, $params)
{
$result = isValidEmail($value, getValueFromArray($params, Flag::VALIDATE_DOMAIN, false));
if (!$result) {
Factory::log()->warn("O e-mail {$value} não é um e-mail válido");
return false;
}
return true;
}
public function testLog()
{
$log = Factory::log();
$this->assertEquals(\Logger::getLogger('main'), $log);
$this->assertEquals(Factory::log(), $log);
Memory::set('debug', true);
$this->assertEquals(\Logger::getLogger('debug'), Factory::log());
Memory::clear('debug');
$this->assertEquals(\Logger::getLogger('main'), $log);
}
/**
* Retorna o enum passado em $params
* @param array $params
* @return BasicEnum
*/
private function getEnum($params)
{
$enumname = getValueFromArray($params, Flag::ENUM_NAME, '');
if (empty($enumname)) {
Factory::log()->fatal('É necessário informar o nome do tipo enum');
require_once PATH_MYFRAME . '/enum/EmptyEnum.php';
return new EmptyEnum();
}
return Factory::enum($enumname);
}
/**
* Cria um novo usuário
*
* @param string $email E-mail do usuário
* @param string $password Deve ser uma senha sem criptografia ou hash
* @param string $nome Nome
* @return int
*/
public function novo($email, $password, $nome)
{
$user = $this->getByEmail($email);
if (empty($user)) {
if (strlen($password) != 60) {
$password = $this->encrypt($password);
}
return $this->insert(array('nome' => $nome, 'email' => $email, 'password' => $password));
}
Factory::log()->warn('O E-mail "' . $email . '" já se encontra cadastrado');
return 0;
}
public static function clear($type = null)
{
if (is_null($type)) {
self::$lastError = null;
self::$errors = array();
} else {
if (isset(self::$errors[$type])) {
unset(self::$errors[$type]);
} else {
Factory::log()->info('O tipo "' . $type . '" não foi definido');
}
}
}
/**
* As configurações são retornadas como um array associativo
*
* @return array Retorna um array vazio em casos de falha
*/
public function load()
{
$this->filename = str_replace("\\", "/", $this->filename);
if (!file_exists($this->filename)) {
Logger::log()->fatal("[" . date("H:i:s") . "] Arquivo de configuração de email não foi encontrado no path {$this->filename}");
return array();
}
$has_parsed = parse_ini_file($this->filename, true);
if (!$has_parsed) {
return array();
}
return $has_parsed;
}
/**
* Retorna o ultimo id inserido
* @param string $nameOrTable Nome da tabela
* @param string $column Nome da coluna
* @return int
*/
public function lastInsertId($nameOrTable = null, $column = null)
{
try {
if (empty($column)) {
return parent::lastInsertId($nameOrTable);
} else {
return parent::lastInsertId($nameOrTable . '_' . $column . '_seq');
}
} catch (PDOException $e) {
Factory::log()->info($e->getMessage());
Factory::log()->fatal("[" . date('H:m:i') . "]Falha ao executar uma query\nerror: {$e->getMessage()}", $e);
return -1;
}
}
/**
* Define um ou mais grupos para o usuário
*
* @param string|int $usuario Email ou id do usuário
* @param mixed $grupos Vetor de ids ou emails ou apenas um id ou email
* @return int Número de grupos inseridos
*/
public function novo($usuario, $grupos)
{
$usuario = $this->getUsuarioId($usuario);
if ($usuario < 0) {
Factory::log()->warn('Usuário inválido');
return 0;
}
if (!is_array($grupos)) {
$grupos = array($grupos);
}
$total = 0;
foreach ($grupos as $grupo) {
$grupo = $this->getGrupoId($grupo);
if ($grupo < 0) {
continue;
}
$total += $this->insert(array('usuario' => $usuario, 'grupo' => $grupo));
}
return $total;
}
public function send(AbstractEmail $email)
{
try {
//Set who the message is to be sent from
$this->mailer->setFrom($email->getFromEmail(), $email->getFromName());
//Set an alternative reply-to address
//$mail->addReplyTo($email->getFromEmail(), $email->getFromName());
$this->mailer->setTo($email->getTo());
$this->mailer->setCc($email->getCc());
$this->mailer->setBCc($email->getBCc());
$this->mailer->setSubject($email->getAssunto());
if ($email instanceof \MyFrameWork\Email\HtmlInterface) {
$mustache = Template::singleton();
$html_body = $mustache->renderHTML(file_get_contents($email->getTemplatePath()), $email->getTemplateParams());
$this->mailer->setMessage($html_body);
} else {
$this->mailer->disableHtml();
$this->mailer->setMessage($email->getMessage());
}
//Replace the plain text body with one created manually
//$mail->AltBody = 'This is a plain-text message body';
$this->mailer->addAttachments($email->getAnexos());
//send the message, check for errors
if (!$this->mailer->send()) {
Logger::log()->fatal("Mailer Send Error: " . $this->mailer->getErrorInfo());
return false;
}
return true;
} catch (phpmailerException $e) {
Logger::log()->fatal("phpmailer Exception : " . $e->errorMessage());
//Pretty error messages from PHPMailer
} catch (\Exception $e) {
Logger::log()->fatal("phpMailer Exception : " . $e->getMessage());
//Boring error messages from anything else!
}
return false;
}
/**
* Verifica se a quantidade de caracteres minímo é válida
* @return boolean
*/
public function validMaxlenght($value, $params)
{
$max = getValueFromArray($params, Flag::MAXLENGHT, strlen($value));
if (!v::string()->length(null, $max)->validate($value)) {
Factory::log()->warn('Valor possui mais do que "' . $max . '" caractere(s)');
return false;
}
return true;
}
/**
* Verifica se o valor é obrigatório e não é vazio
* @return boolean
*/
protected function validRequired($value)
{
if ($this->isEmpty($value)) {
Factory::log()->warn('Valor obrigatório');
return false;
}
return true;
}
/**
* Retorna um queryresult no formato de erro
* @param string $msg Mensagem de erro
* @return array queryresult
*/
protected function returnQueryResultError($msg)
{
Factory::log()->error($msg);
return $this->getQueryResult('', array(), false, $msg);
}
/**
* Limpa um valor da sessão
* @param string $key
*/
public function removeData($key)
{
if (in_array($key, $this->blocked)) {
Factory::log()->debug('A chave "' . $key . '" é um valor protegido e não pode ser removido');
} else {
if (isset($_SESSION[$key])) {
unset($_SESSION[$key]);
}
}
}
/**
* Função genérica que retorna o ID de um campo.
* Funciona apenas para tabelas com chave primária inteiro e única
*
* @param string $campo Nome do campo
* @param string|id $valor Id ou valor do $campo que deve ser um campo da tabela
* @return int Valor do Id ou -1 caso não encontre o campo
*/
protected function getTableId($campo, $valor)
{
if (is_numeric($valor)) {
//Se o valor já é um id retorna-o
return $valor;
}
//Busca pelo id do campo em questão
$result = $this->getByKey($campo, $valor);
if (empty($result)) {
Factory::log()->info('O campo "' . $campo . '" não possui o valor "' . $valor . '" para a tabela: ' . $this->getTableName());
return -1;
}
return $result[$this->pks];
}
/**
* Realiza a limpeza dos parâmetros eliminando os valores inválidos e setando os valores default
*/
protected function cleanParameters()
{
$log = Factory::log();
if (self::isPOSTRequest()) {
$methods = array(RequestType::POST, RequestType::GET);
} else {
$methods = array(RequestType::GET);
}
foreach ($methods as $method) {
foreach ($this->parametersMeta[$method] as $itemname => $itemdata) {
if (isset($this->parametersValue[$itemname])) {
$log->info('Não é possível receber o parâmetro: ' . $itemname . ' por POST/GET');
continue;
}
$received = filter_input(RequestType::getInternalInput($method), $itemname, FILTER_UNSAFE_RAW);
$log->debug('$_' . $method . '["' . $itemname . '"]: ' . var_export($received, true));
$type = Factory::datatype($itemdata['type']);
if ($type->isExpectedToBeArray()) {
$received = filter_input_array(RequestType::getInternalInput($method), array($itemname => array('flags' => FILTER_REQUIRE_ARRAY)));
}
$cleaned = $type->sanitize($received, $itemdata['params']);
//faz os filtros, verifica os tipos e tals
if (!$type->isValid($cleaned, $itemdata['params'])) {
//chama os metodos isValid* da biblioteca respect/Validator
$this->parametersMeta[$method][$itemname]['error'] = LoggerApp::getLastError();
LoggerApp::clear();
continue;
}
if (is_bool($cleaned)) {
$this->parametersValue[$itemname] = var_export($cleaned, true);
} else {
$this->parametersValue[$itemname] = $cleaned;
}
}
}
}
/**
* Realiza um delete no banco de dados
* Se não houver uma condição WHERE por segurança não será executado o comando
*
* @param string $table O nome da tabela
* @param mixed $where Array associativo no formato wherearray ou um objeto Where
*
* example
* $db->delete("tabela1", ['id' => 33])
*
* @return mixed Retorna 0 em caso de falha e boolean em caso de sucesso
*/
public function delete($table, $where)
{
try {
$ret = $this->getQuery()->delete($table, $where);
if ($ret['status']) {
return $this->execute($ret['sql'], $ret['values']);
}
return 0;
} catch (PDOException $e) {
Factory::log()->info("[info]error ao deletar na camada DataBase: " . $e->getMessage());
return 0;
}
}
/**
* Verifica se o valor é negativo
* @param float $value
* @return boolean
*/
protected function validNegative($value)
{
if (!v::numeric()->negative()->validate($value)) {
Factory::log()->warn('Valor deve ser negativo');
return false;
}
return true;
}
/**
*
* @param string $application_config O caminho para o arquivo de configuração
* @return mixed Retorna array em sucesso ou null em caso de falhas. Em casos de falhas é logado os detalhes em temp/log
*/
function getConfig($application_config)
{
$dist = $application_config . ".dist";
$isDev = strpos($application_config, "local");
if ($isDev === false) {
$isDev = false;
}
if (!file_exists($application_config)) {
if (file_exists($dist)) {
$data = file_get_contents($dist);
//se o arquivo não existe então o mesmo é criado
$putted = file_put_contents($application_config, $data);
if (false === $putted) {
Factory::log()->fatal(" não foi possível criar arquivo de configuração : " . $application_config);
return null;
}
//removendo o arquivo de distribuição caso seja ambiente de produção
if (!$isDev) {
$wasDeleted = unlink($dist);
if (!$wasDeleted) {
unlink(realpath($dist));
}
}
$parsedConfigs = parse_ini_file($application_config, true);
if (!$parsedConfigs) {
Factory::log()->fatal(" não foi possivel fazer o parse do arquivo de configuração : " . $application_config);
return null;
}
return $parsedConfigs;
}
Factory::log()->fatal(" não existe nenhum arquivo de configuração : " . $application_config);
return null;
}
$parsedConfigs = parse_ini_file($application_config, true);
if (!$parsedConfigs) {
Factory::log()->fatal(" não foi possivel fazer o parse do arquivo de configuração : " . $application_config);
return null;
}
return $parsedConfigs;
}
/**
* Renderiza varias vezes o mesmo template e retorna um vetor com o conteúdo renderizado
* NÃO imprime o resultado na tela.
*
* @param string $filename O nome do arquivo de template
* @param array $listdata Um vetor de parâmetros que serão passados para o template
* @return array
*/
public function renderLoopTemplate($filename, $listdata)
{
try {
$tpl = $this->loadTemplate($filename);
$content = array();
foreach ($listdata as $data) {
$content[] = $tpl->render($data);
}
return $content;
} catch (Exception $e) {
Factory::log()->info($e->getMessage());
return array();
}
}
/**
* Cria conexões únicas com banco de dados, conforme o driver especificado
*
* @param array $params Array associativo contendo os seguintes dados:
* driver - Banco de dados que será utilizado. Valores suportados: pgsql, mysql
* dbname - Nome do banco de dados
* host - Endereço do banco de dados
* port - Porta utilizada pelo banco
* user - Nome do usuário do banco
* password - Senha do banco de dados
* Se nenhum parâmetro for informado será criado uma conexão padrão, obtida pelas configurações
* @return DataBase Um objeto de conexao com o banco de dados
*/
public static function database($params = array())
{
if (empty($params)) {
$params['driver'] = DATABASE_DRIVER;
$params['dbname'] = DATABASE_NAME;
$params['host'] = DATABASE_HOST;
$params['port'] = DATABASE_PORT;
$params['user'] = DATABASE_USER;
$params['password'] = DATABASE_PASSWORD;
}
//Validate
if (empty($params['driver']) || empty($params['dbname']) || empty($params['user'])) {
Factory::log()->error('Não é possível conectar-se com o banco de dados: "É necessário informar o driver, nome do banco e usuário"');
return null;
}
$host = getValueFromArray($params, 'host');
$dbname = getValueFromArray($params, 'dbname');
$user = getValueFromArray($params, 'user');
$password = getValueFromArray($params, 'password');
$port = getValueFromArray($params, 'port');
$idx = md5($host . $dbname . $user . $password);
if (isset(self::$connections[$idx])) {
return self::$connections[$idx];
}
switch ($params['driver']) {
case 'pgsql':
require_once PATH_MYFRAME . '/src/DataBase/Postgresql.php';
self::$connections[$idx] = new PgDataBase($host, $dbname, $user, $password, $port);
break;
case 'mysql':
require_once PATH_MYFRAME . '/src/DataBase/Mysql.php';
self::$connections[$idx] = new MyDataBase($host, $dbname, $user, $password, $port);
break;
default:
self::log()->error('Não é possível conectar-se com o banco de dados: "Driver {' . $params['driver'] . '} não suportado"');
return null;
//$errorPage = self::page('ErrorPage');
//$errorPage->setErrorMessage('Não é possível conectar-se com o banco de dados: "Driver {' . $params['driver'] . '} não suportado"');
//return $errorPage;
}
return self::$connections[$idx];
}
/**
* @covers LoggerApp::clear
*/
public function testClear()
{
$this->assertEmpty(LoggerApp::getErrors());
Factory::log()->error('error1');
$this->assertNotEmpty(LoggerApp::getErrors());
Factory::log()->warn('warn1');
$this->assertNotEmpty(LoggerApp::getErrors());
LoggerApp::clear('error');
$this->assertNotEmpty(LoggerApp::getErrors());
$this->assertNotEmpty(LoggerApp::getErrors('warn'));
$this->assertEmpty(LoggerApp::getErrors('error'));
Factory::log()->error('error1');
LoggerApp::clear('xyz');
$this->assertNotEmpty(LoggerApp::getErrors('error'));
LoggerApp::clear();
$this->assertEmpty(LoggerApp::getErrors('error'));
$this->assertEmpty(LoggerApp::getErrors('warn'));
$this->assertEmpty(LoggerApp::getErrors());
}
public function testParams()
{
$this->assertEquals('test', $this->dao->getTableName());
$this->assertEquals('id', $this->dao->getPKFieldName());
$this->dao->changeToTable2();
$this->assertEquals('test2', $this->dao->getTableName());
$this->assertEquals(array('id1', 'id2'), $this->dao->getPKFieldName());
$this->assertEquals(Factory::database(), $this->dao->getDatabase());
//Invalid database object - Dont do this
$dao = new MyDAO(Factory::log());
$this->assertEquals(Factory::log(), $dao->getDatabase());
}
