/** * 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()); }