public function testOnFactoryResponseTypes() { $htmlInstace = Factory::response(ResponseType::HTML); $this->assertInstanceOf("MyFrameWork\\Response\\HtmlResponse", $htmlInstace); $emtyInstace = Factory::response(ResponseType::EMPT); $this->assertInstanceOf("MyFrameWork\\Response\\EmptyResponse", $emtyInstace); }
/** * 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)); }
protected function _isValid($value, $params) { $dao = Factory::DAO(getValueFromArray($params, Flag::DAO_NAME, '')); if (!is_null($dao)) { return true; } return false; }
/** * 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)); }
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; }
/** * * @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); }
/** * 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); }
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; }
function createDefaultUser() { echo '<li>CreateDefaultUser</li>'; $dao = Factory::DAO('usuario'); /* @var $dao UsuarioDAO */ $email = '*****@*****.**'; $user = $dao->getByEmail($email); if (empty($user)) { assert($dao->novo('Administrator', $email, hashit('admin'))); $dao = Factory::DAO('usuarioGrupo'); /* @var $dao UsuarioGrupoDAO */ assert($dao->novo($email, 'admin')); } }
protected function createDatabaseItems($folder) { $db = Factory::database(); foreach (glob($folder . '*.sql') as $sqlfile) { echo "<li>{$sqlfile}</li>"; $items = explode(';', file_get_contents($sqlfile)); foreach ($items as $object) { //echo $object . '<br>'; if (!$db->execute($object)) { //echo "<pre>" . $object . "</pre><hr>"; } } } }
/** * 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; } }
public function showPage() { $dao = Factory::DAO('StaticPage'); $page = $dao->getByNome($this->method); if (empty($page)) { redirect('/'); } $this->pageTitle = $page['titulo']; $this->pagedata['nome'] = $page['nome']; $this->pagedata['titulo'] = $page['titulo']; $this->pagedata['conteudo'] = Factory::datatype('html')->toHumanFormat($page['conteudo']); if (empty($this->pageTitle)) { $this->pageTitle = $this->pagedata['titulo']; } }
/** * 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; }
protected function setUp() { LoggerApp::clear(); $this->db = Factory::database(); $this->assertFalse(LoggerApp::hasError(), LoggerApp::getLastError()); $this->assertNotNull($this->db, 'Invalid connection'); $sql = <<<'SQL' CREATE TABLE IF NOT EXISTS test ( id serial PRIMARY KEY, name varchar(40) NOT NULL CHECK (name <> '') ) SQL; try { $this->db->exec($sql); $this->db->exec('DELETE FROM test'); $this->assertTrue($this->db->exec("INSERT INTO test (name) VALUES ('value 1')") > 0); $this->assertTrue($this->db->exec("INSERT INTO test (name) VALUES ('value 2')") > 0); $this->assertTrue($this->db->exec("INSERT INTO test (name) VALUES ('value 3')") > 0); } catch (Exception $e) { $this->fail($e->getMessage()); } }
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; }
/** * 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]); } } }
/** * Carrega um DAO único * * @param string $dao Nome do DAO */ protected function loadDAO($dao) { $dao = ucfirst(str_replace('DAO', '', $dao)); if (!isset($this->daos[$dao])) { $this->daos[$dao] = Factory::DAO($dao, $this->getDatabase()); } return $this->daos[$dao]; }
protected function getDataType($params, $fieldname, $formvalues) { $datatype = Factory::datatype($params['type'])->getHTMLEditable($fieldname, getValueFromArray($formvalues, $fieldname, ''), $params['params']); if (null === $datatype or empty($datatype)) { //tentar criar um datatype da aplicação //$datatype = \Application\Model\DataType\DataTypeFactory::create($params["type"]); } return $datatype; }
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()); }
/** * 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; } }
/** * * @return \Application\Model\Dao\UsuariogrupoDAO */ public function getUsuariogrupoDAO() { return Factory::DAO('usuarioGrupo', $this->getDatabase()); }
* * /[page]/[id]/[action] * /[page]/[id]/[action]?responseType=[format] * * /[page]/[id]/[action]/[format] * * */ require_once "vendor/autoload.php"; /** * Display all errors when APPLICATION_ENV is development. */ if ($_SERVER['APPLICATION_ENV'] == 'development') { error_reporting(E_ALL); ini_set("display_errors", 1); } require_once 'bootstrap.php'; $pageclass = filter_input(INPUT_GET, '_page', FILTER_SANITIZE_STRING); if (empty($pageclass)) { $pageclass = 'main'; } $action = filter_input(INPUT_GET, '_action', FILTER_SANITIZE_STRING); if (empty($action)) { $action = ''; } $type = filter_input(INPUT_GET, 'responseType', FILTER_CALLBACK, array("options" => "ResponseType::getDefaultType")); $page = Factory::page($pageclass); if (filter_has_var(INPUT_GET, '_id')) { $page->setId(filter_input(INPUT_GET, '_id', FILTER_SANITIZE_STRING)); } $page->service(ProcessRequest::getMethod(), $action, $type);
/** * * @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; }
public function testDatatype() { $int = Factory::datatype('int'); $this->assertNotNull($int); $this->assertSame($int, Factory::datatype('int')); $this->assertSame($int, Factory::datatype('Int')); $this->assertSame($int, Factory::datatype('DatatypeInt')); //TODO listar os tipos dinamicamente $datatypes = array('bool', 'boolean', 'email', 'HTML', 'int', 'integer', 'numeric', 'string', 'stringBase', 'text'); foreach ($datatypes as $type) { $type = str_replace('.php', '', $type); if ($type == 'Datatype') { continue; } $this->assertNotNull(Factory::datatype($type), "Falha para o tipo: " . $type); } $this->assertNull(Factory::datatype('invalid')); $this->assertNull(Factory::datatype('Datatype')); }
/** * 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(); } }
/** * 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; }
/** * Adiciona uma lista de parâmetros para um determinado valor * Se o parâmetro existe ele será sobrescrito * * @param string $name Nome do parâmetro * @param string $type Nome do tipo do parâmetro (Deve ser um Datatype) * @param array $params Lista de parâmetros * @param string $method Tipo do método (GET ou POST) se nenhum for informado o método padrão é utilizado * @return ProcessRequest */ protected final function addParameter($name, $type, $params = array(), $method = null) { //Se o tipo é válido if (Factory::datatype($type) != null) { if (!RequestType::isValid($method)) { $method = self::getMethod(); } $this->parametersMeta[$method][$name] = array('type' => $type, 'params' => $params); } return $this; }
/** * @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()); }