public static function updateCategoria()
 {
     $CategoriaTO = new CategoriaTO();
     $CategoriaDao = new CategoriaDao();
     $CategoriaTO->descricao_categoria = isset($_POST['descricao_categoria']) ? $_POST['descricao_categoria'] : '';
     $CategoriaTO->id = isset($_POST['id']) ? $_POST['id'] : '';
     $CategoriaTO->id_pai = isset($_POST['id_pai']) ? $_POST['id_pai'] : NULL;
     $validator = new DataValidator();
     $validator->set_msg('O nome do Categoria é obrigatório')->set('descricao_categoria', $CategoriaTO->descricao_categoria)->is_required();
     $validator->set_msg('O codigo do Categoria é obrigatório')->set('id', $CategoriaTO->id)->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     $empreendimentosAssociados = $_POST['empreendimentos'];
     if ($CategoriaDao->updateCategoria($CategoriaTO)) {
         if (!$CategoriaDao->removeEmpreendimentos($CategoriaTO->id)) {
             Flight::halt(500, 'Erro ao remover empreendimentos associados');
         } else {
             foreach ($empreendimentosAssociados as $key => $empreendimento) {
                 if (!$CategoriaDao->associarEmpreendimento($CategoriaTO->id, $empreendimento['id'])) {
                     Flight::halt(500, 'Erro ao associar empreendimento');
                 }
             }
         }
         Flight::halt(200);
     } else {
         Flight::halt(500, 'Erro ao atualizar dados');
     }
 }

 public static function updateImportador()
 {
     $ImportadorTO = new ImportadorTO();
     $ImportadorDao = new ImportadorDao();
     $ImportadorTO->nome_importador = isset($_POST['nome_importador']) ? $_POST['nome_importador'] : '';
     $ImportadorTO->id = isset($_POST['id']) ? $_POST['id'] : '';
     $validator = new DataValidator();
     $validator->set_msg('O nome do Importador é obrigatório')->set('nome_importador', $ImportadorTO->nome_importador)->is_required();
     $validator->set_msg('O codigo do Importador é obrigatório')->set('id', $ImportadorTO->id)->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     $empreendimentosAssociados = $_POST['empreendimentos'];
     if ($ImportadorDao->updateImportador($ImportadorTO)) {
         if (!$ImportadorDao->removeEmpreendimentos($ImportadorTO->id)) {
             Flight::halt(500, 'Erro ao remover empreendimentos associados');
         } else {
             foreach ($empreendimentosAssociados as $key => $empreendimento) {
                 if (!$ImportadorDao->associarEmpreendimento($ImportadorTO->id, $empreendimento['id'])) {
                     Flight::halt(500, 'Erro ao associar empreendimento');
                 }
             }
         }
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 public static function update()
 {
     $EspecializacaoNcmTO = new EspecializacaoNcmTO();
     $EspecializacaoNcmDao = new EspecializacaoNcmDao();
     $EspecializacaoNcmTO->cod_especializacao_ncm = isset($_POST['cod_especializacao_ncm']) ? $_POST['cod_especializacao_ncm'] : '';
     $EspecializacaoNcmTO->cod_ncm = isset($_POST['cod_ncm']) ? $_POST['cod_ncm'] : '';
     $EspecializacaoNcmTO->ex_tipi = isset($_POST['ex_tipi']) ? $_POST['ex_tipi'] : '';
     $EspecializacaoNcmTO->dsc_especializacao_ncm = isset($_POST['dsc_especializacao_ncm']) ? $_POST['dsc_especializacao_ncm'] : '';
     $EspecializacaoNcmTO->cod_empreendimento = isset($_POST['cod_empreendimento']) ? $_POST['cod_empreendimento'] : '';
     $validator = new DataValidator();
     $validator->set_msg('Este Campo é Obrigatório')->set('cod_especializacao_ncm', $EspecializacaoNcmTO->cod_especializacao_ncm)->is_required();
     $validator->set_msg('Este Campo é Obrigatório')->set('cod_ncm', $EspecializacaoNcmTO->cod_ncm)->is_required();
     $validator->set_msg('Este Campo é Obrigatório')->set('dsc_especializacao_ncm', $EspecializacaoNcmTO->dsc_especializacao_ncm)->is_required();
     $validator->set_msg('Este Campo é Obrigatório')->set('cod_empreendimento', $EspecializacaoNcmTO->cod_empreendimento)->is_required();
     $validator = new DataValidator();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($EspecializacaoNcmDao->update($EspecializacaoNcmTO)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 /**
  * Atualização de um registro
  */
 public function atualizar()
 {
     $this->load->model('configuracoes/niveis_acesso/niveisAcessoModel');
     $this->load->model('configuracoes/modulos/modulosModel');
     $this->load->model('configuracoes/modulos/paginasModel');
     $this->load->model('configuracoes/modulos/actionsModel');
     $id = $this->http->getRequest('id');
     $administrador = $this->http->getRequest('administrador');
     $permissoes = $this->http->getRequest('permissoes');
     $validate = new DataValidator();
     $validate->set('Permissões', $permissoes, 'permissoes')->is_required();
     if ($validate->validate()) {
         $_permissoes = json_decode($permissoes, true);
         $niveisAcesso = new niveisAcessoModel();
         $niveisAcesso->setId($id);
         if (is_null($administrador)) {
             $niveisAcesso = $this->getPermissoes($_permissoes, $niveisAcesso);
         }
         $this->load->dao('configuracoes/niveisAcessoDao');
         $niveisAcessoDao = new niveisAcessoDao();
         $this->http->response($niveisAcessoDao->atualizar($niveisAcesso));
     } else {
         $todos_erros = $validate->get_errors();
         echo json_encode($todos_erros);
     }
 }

 public static function saveDesejo()
 {
     $DesejoClienteTO = new DesejoClienteTO();
     $DesejosClienteDao = new DesejosClienteDao();
     $DesejoClienteTO->id_usuario = isset($_POST['id_usuario']) ? $_POST['id_usuario'] : '';
     $DesejoClienteTO->id_produto = isset($_POST['id_produto']) ? $_POST['id_produto'] : '';
     $DesejoClienteTO->qtd = isset($_POST['qtd']) ? $_POST['qtd'] : '';
     $DesejoClienteTO->sabor_desejado = isset($_POST['sabor_desejado']) ? $_POST['sabor_desejado'] : '';
     $DesejoClienteTO->data_enviado = isset($_POST['data_enviado']) ? $_POST['data_enviado'] : '';
     $DesejoClienteTO->id_empreendimento = isset($_POST['id_empreendimento']) ? $_POST['id_empreendimento'] : '';
     $validator = new DataValidator();
     $validator->set_msg('O cod do usuario é obrigatório')->set('id_usuario', $DesejoClienteTO->id_usuario)->is_required();
     $validator->set_msg('O cod do produto é obrigatório')->set('id_produto', $DesejoClienteTO->id_produto)->is_required();
     $validator->set_msg('A quantidade é obrigatória')->set('qtd', $DesejoClienteTO->qtd)->is_required();
     $validator->set_msg('O sabor é obrigatório')->set('sabor_desejado', $DesejoClienteTO->sabor_desejado)->is_required();
     $validator->set_msg('O cod do Empreendimento é obrigatório')->set('id_empreendimento', $DesejoClienteTO->id_empreendimento)->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     try {
         $DesejosClienteDao->saveDesejo($DesejoClienteTO);
         Flight::halt(201);
     } catch (Exception $e) {
         Flight::halt(500, $e->getMessage());
     }
 }

 public function validate(GatewayType $adapter, $normalized, &$errors)
 {
     if (!isset($normalized['amount']) || !isset($normalized['currency_code'])) {
         // Not enough info to validate
         return;
     }
     if (isset($errors['currency_code'])) {
         // Already displaying an error
         return;
     }
     $value = $normalized['amount'];
     if (self::isZeroIsh($value)) {
         $errors['amount'] = DataValidator::getErrorMessage('amount', 'not_empty', $normalized['language']);
         return;
     }
     $currency = $normalized['currency_code'];
     $min = self::convert($adapter->getGlobal('PriceFloor'), $currency);
     $max = self::convert($adapter->getGlobal('PriceCeiling'), $currency);
     if (!is_numeric($value) || $value < 0) {
         $errors['amount'] = WmfFramework::formatMessage('donate_interface-error-msg-invalid-amount');
     } else {
         if ($value > $max) {
             // FIXME: should format the currency values in this message
             $errors['amount'] = WmfFramework::formatMessage('donate_interface-bigamount-error', $max, $currency, $adapter->getGlobal('MajorGiftsEmail'));
         } else {
             if ($value < $min) {
                 $locale = $normalized['language'] . '_' . $normalized['country'];
                 $formattedMin = self::format($min, $currency, $locale);
                 $errors['amount'] = WmfFramework::formatMessage('donate_interface-smallamount-error', $formattedMin);
             }
         }
     }
 }

    /**
     * Parsuje YOUTUBE
     * @param array $tag wszystkie informacje o tagu
     * @param array $openNode tag otwierajacy
     * @param array $body zawertosc pomiedzy tagiem otwierajacym a zamykajacym
     * @param array $closeNode tak zamykajacy
     * @param BbCodeSettings $settings
     */
    public function checkMovie($tag, &$openNode, &$body, &$closeNode, $settings)
    {
        require_once dirname(__FILE__) . '/../DataValidator.php';
        // wyciagamy caly tekst
        $bodyStr = '';
        foreach ($body as &$el) {
            $bodyStr .= $el['text'];
            // wersja do wyswietlenia
            $el['text'] = '';
        }
        // sprawdzamy czy ciag jest urlem
        $str = DataValidator::checkUrl($bodyStr);
        // skoro nie jest urlem wiec ISTNIEJE prawdopodobienstwo, ze jest to id filmu
        if ($str == false) {
            $idMovie = htmlspecialchars($bodyStr);
        } elseif (preg_match('/watch\\?v=([a-zA-Z0-9_\\-]+)/i', $str, $matches)) {
            // szukanie id filmu
            $idMovie = $matches[1];
        } else {
            // nie ma id wiec lipa
            $openNode = $settings->removeNode($openNode);
            $closeNode = $settings->removeNode($closeNode);
            return false;
        }
        // zamkniecie nie jest nam potrzebne
        $closeNode['text'] = '';
        // Ustawiamy content
        $openNode['text'] = '<iframe title="YouTube video player" width="560" height="349"
src="http://www.youtube.com/embed/' . $idMovie . '?rel=0" frameborder="0">
</iframe>
';
        //ustawiamy link dla zaufanego bbcode
        reset($body);
        $body[key($body)]['tagText'] = $str;
    }

 /**
  * Although this function actually does the filtering, as this is a singleton pattern
  * we only want one instance actually using it.
  *
  * @return bool false if we should stop processing
  */
 private function filter()
 {
     $user_ip = $this->gateway_adapter->getData_Unstaged_Escaped('user_ip');
     // Determine IP status before doing anything complex
     $wl = DataValidator::ip_is_listed($user_ip, $this->gateway_adapter->getGlobal('IPWhitelist'));
     $bl = DataValidator::ip_is_listed($user_ip, $this->gateway_adapter->getGlobal('IPBlacklist'));
     if ($wl) {
         $this->gateway_adapter->debugarray[] = "SessionVelocity: IP present in whitelist.";
         return true;
     }
     if ($bl) {
         $this->gateway_adapter->debugarray[] = "SessionVelocity: IP present in blacklist.";
         return false;
     }
     // Open a session if it doesn't already exist
     $this->gateway_adapter->session_ensure();
     // Obtain some useful information
     $gateway = $this->gateway_adapter->getIdentifier();
     $transaction = $this->gateway_adapter->getCurrentTransaction();
     $cRequestTime = $_SERVER['REQUEST_TIME'];
     $decayRate = $this->getVar('DecayRate', $transaction);
     $threshold = $this->getVar('Threshold', $transaction);
     $multiplier = $this->getVar('Multiplier', $transaction);
     // Initialize the filter
     $sessionData = WmfFramework::getSessionValue(self::SESS_ROOT);
     if (!is_array($sessionData)) {
         $sessionData = array();
     }
     if (!array_key_exists($gateway, $sessionData)) {
         $sessionData[$gateway] = array();
     }
     if (!array_key_exists($transaction, $sessionData[$gateway])) {
         $sessionData[$gateway][$transaction] = array($this::SESS_SCORE => 0, $this::SESS_TIME => $cRequestTime, $this::SESS_MULTIPLIER => 1);
     }
     $lastTime = $sessionData[$gateway][$transaction][self::SESS_TIME];
     $score = $sessionData[$gateway][$transaction][self::SESS_SCORE];
     $lastMultiplier = $sessionData[$gateway][$transaction][self::SESS_MULTIPLIER];
     // Update the filter if it's stale
     if ($cRequestTime != $lastTime) {
         $score = max(0, $score - ($cRequestTime - $lastTime) * $decayRate);
         $score += $this->getVar('HitScore', $transaction) * $lastMultiplier;
         $sessionData[$gateway][$transaction][$this::SESS_SCORE] = $score;
         $sessionData[$gateway][$transaction][$this::SESS_TIME] = $cRequestTime;
         $sessionData[$gateway][$transaction][$this::SESS_MULTIPLIER] = $lastMultiplier * $multiplier;
     }
     // Store the results
     WmfFramework::setSessionValue(self::SESS_ROOT, $sessionData);
     // Analyze the filter results
     if ($score >= $threshold) {
         // Ahh!!! Failure!!! Sloooooooow doooowwwwnnnn
         $this->fraud_logger->alert("SessionVelocity: Rejecting request due to score of {$score}");
         $this->sendAntifraudMessage('reject', $score, array('SessionVelocity' => $score));
         $retval = false;
     } else {
         $retval = true;
     }
     $this->fraud_logger->debug("SessionVelocity: ({$gateway}, {$transaction}) Score: {$score}, " . "AllowAction: {$retval}, DecayRate: {$decayRate}, " . "Threshold: {$threshold}, Multiplier: {$lastMultiplier}");
     return $retval;
 }

 public function testWhitespaceAmount()
 {
     $this->normalized['amount'] = '    ';
     $this->validate();
     $this->assertNotEmpty($this->errors, 'No error for whitespace amount');
     $expected = DataValidator::getErrorMessage('amount', 'not_empty', 'en');
     $this->assertEquals($expected, $this->errors['amount'], 'Wrong error message for whitespace amount');
 }

 /**
  * Oh Shit: It's an actual simple unit test!
  * @covers DataValidator::getZeroPaddedValue()
  */
 public function testGetZeroPaddedValue()
 {
     //make sure that it works in the two main categories of ways it should work
     $this->assertEquals('00123', DataValidator::getZeroPaddedValue('123', 5), "getZeroPaddedValue does not properly pad out a value in the simplest case");
     $this->assertEquals('00123', DataValidator::getZeroPaddedValue('0000123', 5), "getZeroPaddedValue does not properly unpad and re-pad a value when leading zeroes exist in the initial value");
     //make sure it fails gracefully when asked to do something silly.
     $this->assertFalse(DataValidator::getZeroPaddedValue('123456', 5), "getZeroPaddedValue does not return false when the exact desired value is impossible");
 }

 public static function update()
 {
     $base_tributaria = $_POST;
     $BaseTributariaDao = new BaseTributariaDao();
     $base_tributaria['dsc_base_tributaria'] = isset($base_tributaria['dsc_base_tributaria']) ? $base_tributaria['dsc_base_tributaria'] : '';
     $validator = new DataValidator();
     $validator->set_msg('A descrição é obrigatória')->set('dsc_base_tributaria', $base_tributaria['dsc_base_tributaria'])->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($BaseTributariaDao->update($base_tributaria)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 public static function saveOrdemProducao()
 {
     $OrdemProducaoTO = new OrdemProducaoTO();
     $OrdemProducaoDao = new OrdemProducaoDao();
     $OrdemProducaoTO->id_empreendimento = isset($_POST['id_empreendimento']) ? $_POST['id_empreendimento'] : '';
     $OrdemProducaoTO->id_responsavel = isset($_POST['id_responsavel']) ? $_POST['id_responsavel'] : '';
     $OrdemProducaoTO->id_status = isset($_POST['id_status']) ? $_POST['id_status'] : 1;
     $OrdemProducaoTO->id_deposito = isset($_POST['id_deposito']) ? $_POST['id_deposito'] : '';
     $itens = isset($_POST['itens']) && is_array($_POST['itens']) ? $_POST['itens'] : false;
     $Dao = new Dao();
     $Dao->setTimeZone($OrdemProducaoTO->id_empreendimento);
     $OrdemProducaoTO->dta_create = date('Y-m-d H:m:i');
     $validator = new DataValidator();
     $validator->set_msg('O Responsavel é obrigatório')->set('id_responsavel', $OrdemProducaoTO->id_responsavel)->is_required();
     $validator->set_msg('O Depósito é obrigatório')->set('nme_deposito', $OrdemProducaoTO->id_deposito)->is_required();
     if ($itens == false) {
         $validator->_errors['itens'][] = 'É obrigatório informar ao menos um produto a ser produzido';
     }
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     try {
         $id_ordem_producao = $OrdemProducaoDao->saveOrdemProducao($OrdemProducaoTO);
         if (!$id_ordem_producao) {
             Flight::halt(500, 'Erro ao cadastrar ordem de producão');
         }
         $ItensOrdemProducaoTO = new ItensOrdemProducaoTO();
         $ItensOrdemProducaoDao = new ItensOrdemProducaoDao();
         foreach ($itens as $key => $value) {
             $ItensOrdemProducaoTO->id_ordem_producao = $id_ordem_producao;
             $ItensOrdemProducaoTO->id_produto = $value['id'];
             $ItensOrdemProducaoTO->qtd = $value['qtd'];
             if (!$ItensOrdemProducaoDao->saveItensOrdemProducao($ItensOrdemProducaoTO)) {
                 Flight::halt(500, 'Erro ao cadastrar itens ordem de producão');
             }
         }
         if (!$OrdemProducaoDao->savechangeOrdemProducao($id_ordem_producao, $OrdemProducaoTO->id_status, $OrdemProducaoTO->dta_create)) {
             Flight::halt(500, 'Erro ao cadastrar mudança de status');
         }
         Flight::halt(201);
     } catch (Exception $e) {
         Flight::halt(500, $e->getMessage());
     }
 }

 public static function update()
 {
     try {
         $SerieDocumentoFiscalTO = new SerieDocumentoFiscalTO();
         $SerieDocumentoFiscalDao = new SerieDocumentoFiscalDao();
         $SerieDocumentoFiscalTO->id = $_POST['id'];
         $SerieDocumentoFiscalTO->cod_empreendimento = isset($_POST['cod_empreendimento']) ? $_POST['cod_empreendimento'] : NULL;
         $SerieDocumentoFiscalTO->serie_documento_fiscal = isset($_POST['serie_documento_fiscal']) ? $_POST['serie_documento_fiscal'] : NULL;
         $SerieDocumentoFiscalTO->num_modelo_documento_fiscal = isset($_POST['num_modelo_documento_fiscal']) ? $_POST['num_modelo_documento_fiscal'] : NULL;
         $SerieDocumentoFiscalTO->num_ultimo_documento_fiscal = isset($_POST['num_ultimo_documento_fiscal']) ? $_POST['num_ultimo_documento_fiscal'] : NULL;
         $validator = new DataValidator();
         $validator->set_msg('Este campo é obrigatório')->set('descricao_categoria', $SerieDocumentoFiscalTO->cod_empreendimento)->is_required();
         $validator->set_msg('Este campo é obrigatório')->set('descricao_categoria', $SerieDocumentoFiscalTO->serie_documento_fiscal)->is_required();
         $validator->set_msg('Este campo é obrigatório')->set('descricao_categoria', $SerieDocumentoFiscalTO->num_modelo_documento_fiscal)->is_required();
         $validator->set_msg('Este campo é obrigatório')->set('descricao_categoria', $SerieDocumentoFiscalTO->num_ultimo_documento_fiscal)->is_required();
         if (!$validator->validate()) {
             Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
             return;
         }
         $conn = Conexao::getInstance();
         $conn->beginTransaction();
         $SerieDocumentoFiscalDao->update($SerieDocumentoFiscalTO);
         $conn->commit();
         Flight::halt(201);
     } catch (Exception $e) {
         $conn->rollback();
         echo $e->getMessage();
     }
 }

 public static function updatePlanoConta()
 {
     $PlanoContasTO = new PlanoContasTO();
     $PlanoContasDao = new PlanoContasDao();
     $PlanoContasTO->id = isset($_POST['id']) ? $_POST['id'] : '';
     $PlanoContasTO->cod_plano = isset($_POST['cod_plano']) ? $_POST['cod_plano'] : '';
     $PlanoContasTO->dsc_plano = isset($_POST['dsc_plano']) ? $_POST['dsc_plano'] : '';
     $PlanoContasTO->id_plano_pai = isset($_POST['id_plano_pai']) ? $_POST['id_plano_pai'] : NULL;
     $validator = new DataValidator();
     $validator->set_msg('O id do plano é obrigatório')->set('id', $PlanoContasTO->cod_plano)->is_required();
     $validator->set_msg('O código do plano é obrigatório')->set('cod_plano', $PlanoContasTO->cod_plano)->is_required();
     $validator->set_msg('A descrição do plano é obrigatório')->set('dsc_plano', $PlanoContasTO->dsc_plano)->is_required();
     if (!is_null($PlanoContasTO->id_plano_pai)) {
         $validator->set_msg('O ID do plano pai não é valido')->set('id_plano_pai', $PlanoContasTO->id_plano_pai)->is_required();
     }
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($PlanoContasDao->updatePlanoConta($PlanoContasTO)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 public static function saveCorProduto()
 {
     $CorProdutoDao = new CorProdutoDao();
     $nome_cor = isset($_POST['nome_cor']) ? $_POST['nome_cor'] : '';
     $empreendimentos = isset($_POST['empreendimentos']) ? $_POST['empreendimentos'] : '';
     $validator = new DataValidator();
     $validator->set_msg('O nome da cor/sabor é obrigatório')->set('nome_cor', $nome_cor)->is_required();
     $validator->set_msg('Informe ao menos um empreendimento')->set('empreendimentos', $empreendimentos)->is_arr();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     $emp_cadastrados = $CorProdutoDao->CorProdutoExists($nome_cor, $empreendimentos);
     $change = is_bool($emp_cadastrados) ? true : !$emp_cadastrados['change'];
     $id_cor_produto = is_bool($emp_cadastrados) ? null : $emp_cadastrados['id_cor_produto'];
     $emp_cadastrados = is_bool($emp_cadastrados) ? $emp_cadastrados : $emp_cadastrados['empreendimentos'];
     if (is_bool($emp_cadastrados) && $emp_cadastrados == true) {
         $validator->_errors['nome_cor'][] = 'Está cor já está cadastrada';
     }
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     $empreendimentos = $emp_cadastrados;
     $last_id = $CorProdutoDao->saveCorProduto($nome_cor, $empreendimentos, $change, $id_cor_produto);
     if ($last_id) {
         Flight::response()->status(201)->header('Content-Type', 'application/json')->write(json_encode(array('id' => $last_id)))->send();
     } else {
         Flight::halt(500, 'erro ao inserir cor');
     }
 }

 public static function save()
 {
     $perfilTO = new PerfilTO();
     $perfilTO->cod_perfil = isset($_POST['cod_perfil']) ? $_POST['cod_perfil'] : "";
     $perfilTO->nme_perfil = isset($_POST['nme_perfil']) ? $_POST['nme_perfil'] : "";
     $perfilTO->flg_ativo = isset($_POST['flg_ativo']) ? $_POST['flg_ativo'] : array();
     $perfilTO->modulos = isset($_POST['modulos']) ? $_POST['modulos'] : array();
     $validator = new DataValidator();
     $validator->set_msg('A Descrição é obrigatória')->set('nme_perfil', $perfilTO->nme_perfil)->is_required();
     if (count($modulos) == 0) {
         $validator->set_msg('Selecione ao menos um módulo')->set('modulos', $perfilTO->modulos)->set_custom_error();
     }
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     try {
         $perfilDao = new PerfilDao();
         if ($cod_perfil === "") {
             $perfilTO->cod_perfil = $perfilDao->savePerfil($perfilTO);
         } else {
             if (!$perfilDao->updatePerfil($perfilTO)) {
                 Flight::halt(500, "Falha ao atualizar o perfil [" . $perfilTO->nme_perfil . "]");
             }
         }
         if ($perfilTO->cod_perfil) {
             $moduloPerfilDao = new ModuloPerfilDao();
             if ($moduloPerfilDao->deleteAllModulosPerfil($perfilTO->cod_perfil)) {
                 foreach ($modus as $key => $modulo) {
                     $moduloPerfilTO = new ModuloPerfilTO();
                     $moduloPerfilTO->cod_modulo = $modulo['cod_modulo'];
                     $moduloPerfilTO->cod_perfil = $perfilTO->cod_perfil;
                     if (!$moduloPerfilDao->saveModuloPerfil($moduloPerfilTO)) {
                         Flight::halt(500, "Falha ao gravar os módulos ao perfil [" . $perfilTO->nme_perfil . "]");
                     }
                 }
             }
         } else {
             Flight::halt(500, "Falha ao salvar o perfil [" . $perfilTO->nme_perfil . "]");
         }
     } catch (PDOException $e) {
         Flight::halt(500, $e->getMessage());
     }
 }

 public static function update()
 {
     $situacao = $_POST;
     $SituacaoEspecialDao = new SituacaoEspecialDao();
     $situacao['dsc_situacao_especial'] = isset($situacao['dsc_situacao_especial']) ? $situacao['dsc_situacao_especial'] : '';
     $situacao['cod_empreendimento'] = isset($situacao['cod_empreendimento']) ? $situacao['cod_empreendimento'] : '';
     $validator = new DataValidator();
     $validator->set_msg('A descrição é obrigatória')->set('dsc_situacao_especial', $situacao['dsc_situacao_especial'])->is_required();
     $validator->set_msg('O id do Empreendimento é obrigatório')->set('cod_empreendimento', $situacao['cod_empreendimento'])->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($SituacaoEspecialDao->update($situacao)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 public static function update()
 {
     $RegraTributosTO = new RegraTributosTO();
     $RegraTributosDao = new RegraTributosDao();
     $RegraTributosTO->dsc_regra_tributos = isset($_POST['dsc_regra_tributos']) ? $_POST['dsc_regra_tributos'] : '';
     $RegraTributosTO->cod_regra_tributos = isset($_POST['cod_regra_tributos']) ? $_POST['cod_regra_tributos'] : '';
     $validator = new DataValidator();
     $validator->set_msg('O Campo descrição é obrigatório')->set('dsc_regra_tributos', $RegraTributosTO->dsc_regra_tributos)->is_required();
     $validator->set_msg('O codigo é obrigatorio')->set('cod_regra_tributos', $RegraTributosTO->dsc_regra_tributos)->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($RegraTributosDao->update($RegraTributosTO)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 public static function updateDeposito()
 {
     $DepositoTO = new DepositoTO();
     $DepositoDao = new DepositoDao();
     $DepositoTO->nme_deposito = isset($_POST['nme_deposito']) ? $_POST['nme_deposito'] : '';
     $DepositoTO->id = isset($_POST['id']) ? $_POST['id'] : '';
     $validator = new DataValidator();
     $validator->set_msg('O nome do Deposito é obrigatório')->set('nme_deposito', $DepositoTO->nme_deposito)->is_required();
     $validator->set_msg('O codigo do Deposito é obrigatório')->set('id', $DepositoTO->id)->is_required();
     if (!$validator->validate()) {
         Flight::response()->status(406)->header('Content-Type', 'application/json')->write(json_encode($validator->get_errors()))->send();
         return;
     }
     if ($DepositoDao->updateDeposito($DepositoTO)) {
         Flight::halt(200);
     } else {
         Flight::halt(500, 'erro ao atualizar');
     }
 }

 /**
  * Verifica se o dado passado e um numero inteiro
  * @param mixed $mx_value;
  * @return boolean
  */
 static function isInteger($mx_value)
 {
     if (!DataValidator::isNumeric($mx_value)) {
         return false;
     }
     if (preg_match('/[[:punct:]&^-]/', $mx_value) > 0) {
         return false;
     }
     return true;
 }