Retorna a form para o cadastro da entidade.
962480
public function getForm($entityClass = null)
    {
        if (null === $entityClass) {
            $entityClass = $this->getEntityClass();
        }

        $builder = new AnnotationBuilder();
        $form = $builder->createForm($entityClass);

        $hasEntity = false;
        foreach ($form->getElements() as $element) {
            if (method_exists($element, 'setObjectManager')) {
                $element->setObjectManager($this->getEntityManager());
                $hasEntity = true;
            } elseif (method_exists($element, 'getProxy')) {
                $proxy = $element->getProxy();
                if (method_exists($proxy, 'setObjectManager')) {
                    $proxy->setObjectManager($this->getEntityManager());
                    $hasEntity = true;
                }
            }
        }

        if ($hasEntity) {
            $hydrator = new DoctrineHydrator($this->getEntityManager(), $entityClass);
            $form->setHydrator($hydrator);
        } else {
            $form->setHydrator(new ClassMethods());
        }

        $form->add([
            'type' => 'Zend\Form\Element\Csrf',
            'name' => 'csrf',
            'attributes' => [
                'id' => 'csrf',
            ],
        ]);

        $submitElement = new \Zend\Form\Element\Button('submit');
        $submitElement->setAttributes([
            'type' => 'submit',
            'class' => 'btn btn-primary',
        ]);
        $submitElement->setLabel('Salvar');
        $form->add($submitElement, [
            'priority' => -100,
        ]);

        $cancelarElement = new \Zend\Form\Element\Button('cancelar');
        $cancelarElement->setAttributes([
            'type' => 'button',
            'class' => 'btn btn-default',
            'onclick' => 'top.location=\''.$this->url()
                ->fromRoute($this->getActionRoute('list')).'\'',
        ]);
        $cancelarElement->setLabel('Cancelar');
        $form->add($cancelarElement, [
            'priority' => -100,
        ]);

        return $form;
    }
320183
def AnularCertificacion(self, coe):
        ""
        ret = self.client.cgSolicitarAnulacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        self.Estado = ret.get('estadoCertificado', "")
        return self.COE
820517
def fill(self, fase, estado):
        """"""
        fase.rho = estado["rho"]
        fase.v = 1/fase.rho

        fase.h = estado["h"]
        fase.s = estado["s"]
        fase.u = fase.h-self.P*1000*fase.v
        fase.a = fase.u-self.T*fase.s
        fase.g = fase.h-self.T*fase.s

        fase.Z = self.P*fase.v/self.T/self.R*1e3
        fase.fi = exp(estado["fir"]+estado["delta"]*estado["fird"] -
                      log(1+estado["delta"]*estado["fird"]))
        fase.f = fase.fi*self.P
        fase.cv = estado["cv"]

        fase.rhoM = fase.rho/self.M
        fase.hM = fase.h*self.M
        fase.sM = fase.s*self.M
        fase.uM = fase.u*self.M
        fase.aM = fase.a*self.M
        fase.gM = fase.g*self.M

        fase.alfap = estado["alfap"]
        fase.betap = estado["betap"]

        fase.cp = self.derivative("h", "T", "P", fase)
        fase.cp_cv = fase.cp/fase.cv
        fase.w = (self.derivative("P", "rho", "s", fase)*1000)**0.5
        fase.cvM = fase.cv*self.M
        fase.cpM = fase.cp*self.M

        fase.joule = self.derivative("T", "P", "h", fase)*1e3
        fase.Gruneisen = fase.v/fase.cv*self.derivative("P", "T", "v", fase)
        fase.alfav = self.derivative("v", "T", "P", fase)/fase.v
        fase.kappa = -self.derivative("v", "P", "T", fase)/fase.v*1e3
        fase.betas = self.derivative("T", "P", "s", fase)

        fase.gamma = -fase.v/self.P*self.derivative("P", "v", "s", fase)*1e-3
        fase.kt = -fase.v/self.P*self.derivative("P", "v", "T", fase)*1e-3
        fase.ks = -self.derivative("v", "P", "s", fase)/fase.v*1e3
        fase.Kt = -fase.v*self.derivative("P", "v", "s", fase)*1e-3
        fase.Ks = -fase.v*self.derivative("P", "v", "T", fase)*1e-3
        fase.dhdT_rho = self.derivative("h", "T", "rho", fase)
        fase.dhdT_P = self.derivative("h", "T", "P", fase)
        fase.dhdP_T = self.derivative("h", "P", "T", fase)*1e3
        fase.dhdP_rho = self.derivative("h", "P", "rho", fase)*1e3
        fase.dhdrho_T = self.derivative("h", "rho", "T", fase)
        fase.dhdrho_P = self.derivative("h", "rho", "P", fase)
        fase.dpdT_rho = self.derivative("P", "T", "rho", fase)*1e-3
        fase.dpdrho_T = self.derivative("P", "rho", "T", fase)*1e-3
        fase.drhodP_T = self.derivative("rho", "P", "T", fase)*1e3
        fase.drhodT_P = self.derivative("rho", "T", "P", fase)

        fase.Z_rho = (fase.Z-1)/fase.rho
        fase.IntP = self.T*self.derivative("P", "T", "rho", fase)*1e-3-self.P
        fase.hInput = fase.v*self.derivative("h", "v", "P", fase)

        fase.mu = self._visco(fase.rho, self.T, fase)
        fase.k = self._thermo(fase.rho, self.T, fase)
        fase.nu = fase.mu/fase.rho
        fase.alfa = fase.k/1000/fase.rho/fase.cp
        fase.Prandt = fase.mu*fase.cp*1000/fase.k
        if self.name == "water":
            try:
                fase.epsilon = _Dielectric(fase.rho, self.T)
            except NotImplementedError:
                fase.epsilon = None

            try:
                fase.n = _Refractive(fase.rho, self.T, self.kwargs["l"])
            except NotImplementedError:
                fase.n = None
        else:
            fase.epsilon = None
            fase.n = None
779932
def AutorizarRemito(self, archivo="qr.png"):
        ""
        response = self.client.autorizarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                codRemito=self.remito['codRemito'],
                                estado=self.remito['estado'])
        ret = response.get("autorizarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)
1224437
def detalhe(self, posicao=0):
        """"""
        handle = self._url_open('detalheCEPAction.do', {'Metodo': 'detalhe',
                                                        'TipoCep': 2,
                                                        'Posicao': posicao + 1,
                                                        'CEP': ''})
        html = handle.read()
        return self._parse_detalhe(html)
245338
def create_tipo_roteiro(self):
        """"""
        return TipoRoteiro(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
732107
public function formProperties()
    {
        $form = $this->form();
        $obj  = ($form instanceof ObjectContainerInterface) ? $form->obj() : null;

        $groupProperties = $this->groupProperties();
        $formProperties  = $this->parsedFormProperties();
        $propOptions     = $this->propertiesOptions();

        foreach ($formProperties as $propertyIdent => $formProperty) {
            if (in_array($propertyIdent, $groupProperties)) {
                if (!empty($propOptions[$propertyIdent])) {
                    $propertyOptions = $propOptions[$propertyIdent];

                    if (is_array($propertyOptions)) {
                        $formProperty->merge($propertyOptions);
                    }
                }

                if ($obj) {
                    $val = $obj[$propertyIdent];
                    $formProperty->setPropertyVal($val);
                }

                if (!$formProperty->l10nMode()) {
                    $formProperty->setL10nMode($this->l10nMode());
                }

                if ($formProperty instanceof FormInputInterface) {
                    $formProperty->setFormGroup($this);
                }

                yield $propertyIdent => $formProperty;

                if ($formProperty instanceof FormInputInterface) {
                    $formProperty->clearFormGroup();
                }
            }
        }
    }
817039
def AjustarLiquidacionUnificado(self):
        ""
        
        # limpiar estructuras no utilizadas (si no hay deducciones / retenciones)
        for k in ('ajusteDebito', 'ajusteCredito'):
            if not any(self.ajuste[k].values()):
                del self.ajuste[k]
            else:
                if not self.ajuste[k]['deducciones']:
                    del self.ajuste[k]['deducciones']
                if not self.ajuste[k]['retenciones']:
                    del self.ajuste[k]['retenciones']

        # llamar al webservice:
        ret = self.client.liquidacionAjustarUnificado(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        **self.ajuste
                        )
        # analizar el resultado:
        ret = ret['ajusteUnifReturn']
        self.__analizar_errores(ret)
        if 'ajusteUnificado' in ret:
            aut = ret['ajusteUnificado']
            self.AnalizarAjuste(aut)
        return True
314016
public function ___get($prop)
    {
        // retorna o valor da propriedade
        if (isset($this->meta[$prop])) {
            $metaData = (isset($this->meta[$prop])) ? $this->meta[$prop] : null;
            switch ($metaData['tipo']) {
                case 'decimal':
                    return ($this->data[$prop]) ? number_format($this->data[$prop], $metaData['precision'], ',', '.') : '';
                case 'int':
                    return (isset($this->data[$prop])) ? abs($this->data[$prop]) : '';
                case 'alfa':
                    return ($this->data[$prop]) ? $this->prepareText($this->data[$prop]) : '';
                case $metaData['tipo'] == 'date' && $metaData['tamanho'] == 6:
                    return ($this->data[$prop]) ? date("d/m/y", strtotime($this->data[$prop])) : '';
                case $metaData['tipo'] == 'date' && $metaData['tamanho'] == 8:
                    return ($this->data[$prop]) ? date("d/m/Y", strtotime($this->data[$prop])) : '';
                default:
                    return null;
            }
        }
    }
909109
def SolicitarCTGInicial(self, numero_carta_de_porte, codigo_especie,
        cuit_canjeador, cuit_destino, cuit_destinatario, codigo_localidad_origen,
        codigo_localidad_destino, codigo_cosecha, peso_neto_carga, 
        cant_horas=None, patente_vehiculo=None, cuit_transportista=None, 
        km_a_recorrer=None, remitente_comercial_como_canjeador=None, 
        cuit_corredor=None, remitente_comercial_como_productor=None, 
        turno=None,
        **kwargs):
        ""
        # ajusto parámetros según validaciones de AFIP:
        if not cuit_canjeador or int(cuit_canjeador) == 0:
            cuit_canjeador = None         # nulo
        if not cuit_corredor or int(cuit_corredor) == 0:
            cuit_corredor = None         # nulo
        if not remitente_comercial_como_canjeador:
            remitente_comercial_como_canjeador = None
        if not remitente_comercial_como_productor:
            remitente_comercial_como_productor = None
        if turno == '':
            turno  = None                # nulo

        ret = self.client.solicitarCTGInicial(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                         datosSolicitarCTGInicial=dict(
                            cartaPorte=numero_carta_de_porte, 
                            codigoEspecie=codigo_especie,
                            cuitCanjeador=cuit_canjeador or None, 
                            remitenteComercialComoCanjeador=remitente_comercial_como_canjeador,
                            cuitDestino=cuit_destino, 
                            cuitDestinatario=cuit_destinatario, 
                            codigoLocalidadOrigen=codigo_localidad_origen,
                            codigoLocalidadDestino=codigo_localidad_destino, 
                            codigoCosecha=codigo_cosecha, 
                            pesoNeto=peso_neto_carga, 
                            cuitTransportista=cuit_transportista,
                            cantHoras=cant_horas,
                            patente=patente_vehiculo, 
                            kmARecorrer=km_a_recorrer,
                            cuitCorredor=cuit_corredor,
                            remitenteComercialcomoProductor=remitente_comercial_como_productor,
                            turno=turno,
                            )))['response']
        self.__analizar_errores(ret)
        self.Observaciones = ret['observacion']
        datos = ret.get('datosSolicitarCTGResponse')
        if datos:
            self.CartaPorte = str(datos['cartaPorte'])
            datos_ctg = datos.get('datosSolicitarCTG')
            if datos_ctg:
                self.NumeroCTG = str(datos_ctg['ctg'])
                self.FechaHora = str(datos_ctg['fechaEmision'])
                self.VigenciaDesde = str(datos_ctg['fechaVigenciaDesde'])
                self.VigenciaHasta = str(datos_ctg['fechaVigenciaHasta'])
                self.TarifaReferencia = str(datos_ctg.get('tarifaReferencia'))
            self.__analizar_controles(datos)
        return self.NumeroCTG or 0
1330418
def AnularCTG(self, carta_porte, ctg):
        ""
        response = self.client.anularCTG(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosAnularCTG={
                            'cartaPorte': carta_porte,
                            'ctg': ctg, }))['response']
        datos = response.get('datosResponse')
        self.__analizar_errores(response)
        if datos:
            self.CartaPorte = str(datos['cartaPorte'])
            self.NumeroCTG = str(datos['ctg'])
            self.FechaHora = str(datos['fechaHora'])
            self.CodigoOperacion = str(datos['codigoOperacion'])
881686
def ConsultarDepositosAcopio(self, sep="||"):
        ""
        ret = self.client.consultarDepositosAcopio(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('acopio', [])
        if sep is None:
            return array
        else:
            return [("%s %%s %s %%s %s %%s %s %%s %s" % (sep, sep, sep, sep, sep)) %
                    (it['codigo'], it['direccion'], it['localidad'], it['codigoPostal']) 
                    for it in array]
989580
public function resumoPermissoesPorPerfil($perfilId)
    {
        $permissoesQtd = DB::table('autenticacao_perfis_permissoes')
            ->select(DB::raw('COUNT(permissoes.group)'))
            ->join('autenticacao_permissoes as permissoes', function ($query) {
                $query->on('permissoes.id', '=', 'autenticacao_perfis_permissoes.permissao_id')
                    ->whereNull('permissoes.deleted_at');
            })
            ->where('autenticacao_perfis_permissoes.perfil_id', '=', $perfilId)
            ->whereRaw('permissoes.group = autenticacao_permissoes.group');

        return $this->model
            ->select(
                '*',
                DB::raw("({$permissoesQtd->toSql()}) as qtd_adicionada"),
                DB::raw('COUNT(autenticacao_permissoes.id) as qtd_permissoes')
            )
            ->groupBy('autenticacao_permissoes.group')
            ->mergeBindings($permissoesQtd);
    }
214730
protected function createComponentSocialForm() : Form
    {
        $form = new Form;

        $form->addText('title')
            ->setRequired('Titulek pro sociální sítě je povinný.')
            ->addRule(Form::MIN_LENGTH, 'Minimální délka titulku jsou %d znaky.', 3)
            ->addRule(Form::MAX_LENGTH, 'Maximální délka titulku je %d znaků.', 50);

        $form->addText('description')
            ->setRequired(FALSE)
            ->addRule(Form::MIN_LENGTH, 'Minimální délka popisu jsou %d znaky.', 3)
            ->addRule(Form::MAX_LENGTH, 'Maximální délka popisu je %d znaků.', 50);

        $form->addUpload('image')
            ->setRequired(FALSE)
            ->addRule(Form::IMAGE, 'Obrázek může být pouze JPG or PNG.')
            ->addRule(Form::MIME_TYPE, 'Obrázek musí mít správný mime-type.', ['image/jpeg', 'image/png'])
            ->addRule(Form::MAX_FILE_SIZE, 'Maximální velikost obrázku je 8 MB.', 1024 * 1024 * 8)
            ->addRule(Form::PATTERN, 'Obrázek musí mít koncovku .jpg, .png.', '.*\.(jpg|png)');

        $form->addSubmit('save');


        $onPageSocial = $this->activePage->getSocial();

        if ($onPageSocial)
        {
            $form->setDefaults([
                'title' => $onPageSocial->getTitle(),
                'description' => $onPageSocial->getDescription()
            ]);
        }

        $form->onValidate[] = function (Form $form) { $this->validate($form); };
        $form->onSuccess[] = function (Form $form) { $this->success($form); };

        if (!$this->presenter->user->isAllowed(OnPageAuthorizator::RES_SOCIAL))
        {
            $this->setDisabledForm($form);
        }

        return $form;
    }
615813
public function validarDadosObrigatorios()
    {
        if (null === $this->getValorDocumento()) {
            $this->erros['valor'] = 'Valor do documento é obrigatório';
        }
        if (null === $this->getConvenio()->getBanco()->getAgencia()) {
            $this->erros['agencia'] = 'Agência do banco é obrigatório';
        }
        if (null === $this->getConvenio()->getBanco()->getConta()) {
            $this->erros['conta'] = 'Conta do banco é obrigatório';
        }
        if (null === $this->getConvenio()->getCarteira()->getNumero()) {
            $this->erros['carteira'] = 'Carteira do convênio é obrigatório';
        }
        if (!empty($this->erros)) {
            $dadosFaltantes = implode("', '", array_keys($this->erros));
            throw new \InvalidArgumentException("Faltam dados a serem fornecidos ao boleto. ('{$dadosFaltantes}')");
        }
    }
4276
public function form()
    {
        $permissionModel = config('admin.database.permissions_model');

        $form = new Form(new $permissionModel());

        $form->display('id', 'ID');

        $form->text('slug', trans('admin.slug'))->rules('required');
        $form->text('name', trans('admin.name'))->rules('required');

        $form->multipleSelect('http_method', trans('admin.http.method'))
            ->options($this->getHttpMethodsOptions())
            ->help(trans('admin.all_methods_if_empty'));
        $form->textarea('http_path', trans('admin.http.path'));

        $form->display('created_at', trans('admin.created_at'));
        $form->display('updated_at', trans('admin.updated_at'));

        return $form;
    }
989016
def AgregarDatosAutorizacion(self, nro_remito=None, cod_autorizacion=None, fecha_emision=None, fecha_vencimiento=None, **kwargs):
        ""
        self.remito['datosEmision'] = dict(nroRemito=nro_remito, codAutorizacion=cod_autorizacion,
                                                fechaEmision=fecha_emision, fechaVencimiento=fecha_vencimiento,
                                               )
        return True