py4web 1.20201112.1 - en to pt translation catalogue (66 entries)

en: Authentication and Access control
pt: Autenticação e controle de acesso

en: **Warning: the API described in this chapter is new and subject to changes. Make sure you keep your code up to date**
pt: ** Atenção: a API descrito neste capítulo é novo e sujeitas a alterações. Certifique-se de manter seu código atualizado **

en: py4web comes with a an object Auth and a system of plugins for user authentication and access control. It has the same name as the corresponding web2py one and serves the same purpose but the API and internal design is very different.
pt: py4web vem com um um objecto Auth e um sistema de encaixes para a autenticação do utilizador e de controlo de acesso. Ele tem o mesmo nome que o web2py correspondente e tem a mesma finalidade, mas a API e design interno é muito diferente.

en: To use it, first of all you need to import it, instantiate it, configure it, and enable it.
pt: Para usá-lo, em primeiro lugar você precisa importá-lo, instanciá-lo, configurá-lo, e habilitá-lo.

en: The import step is obvious. The second step does not perform any operation other than telling the Auth object which session object to use and which database to use. Auth data is stored in ``session['user']`` and, if a user is logged in, the user id is stored in session[‘user’][‘id’]. The db object is used to store persistent info about the user in a table ``auth_user`` with the following fields:
pt: A etapa de importação é óbvia. A segunda etapa não executar qualquer operação que não dizendo o objeto Auth qual objeto sessão para usar e qual banco de dados para uso. Auth dados são armazenados em `` sessão [ 'user'] `` e, se um usuário estiver logado, o ID do usuário é armazenado na sessão [ ‘user’] [ ‘id’]. O objecto dB é utilizado para armazenar informação sobre o utilizador persistente numa tabela `` auth_user`` com os seguintes campos:

en: username
pt: nome do usuário

en: email
pt: o email

en: password
pt: senha

en: first_name
pt: primeiro nome

en: last_name
pt: último nome

en: sso_id (used for single sign on, see later)
pt: sso_id (usado para single sign on, ver mais adiante)

en: action_token (used to verify email, block users, and other tasks, also see later).
pt: action_token (usado para verificar e-mail, bloquear usuários e outras tarefas, também ver mais adiante).

en: If the ``auth_user`` table does not exist it is created.
pt: Se o `` auth_user`` tabela não existir ele será criado.

en: The configuration step is optional and discussed later.
pt: A etapa de configuração é opcional e discutida mais tarde.

en: The ``auth.enable()`` step creates and exposes the following RESTful APIs:
pt: A `` auth.enable () `` passo cria e expõe os seguintes APIs RESTful:

en: {appname}/auth/api/register (POST)
pt: {Nomeaplic} / auth / api / registo (POST)

en: {appname}/auth/api/login (POST)
pt: {Nomeaplic} / auth / api / Login (POST)

en: {appname}/auth/api/request_reset_password (POST)
pt: {Nomeaplic} / auth / api / request_reset_password (POST)

en: {appname}/auth/api/reset_password (POST)
pt: {Nomeaplic} / auth / api / reset_password (POST)

en: {appname}/auth/api/verify_email (GET, POST)
pt: {Appname} / auth / api / verify_email (GET, POST)

en: {appname}/auth/api/logout (GET, POST) (+)
pt: {Nomeaplic} / auth / api / Sair (GET, POST) (+)

en: {appname}/auth/api/profile (GET, POST) (+)
pt: {Nomeaplic} / auth / api / perfil (GET, POST) (+)

en: {appname}/auth/api/change_password (POST) (+)
pt: {Nomeaplic} / auth / api / change_password (POST) (+)

en: {appname}/auth/api/change_email (POST) (+)
pt: {Nomeaplic} / auth / api / change_email (POST) (+)

en: Those marked with a (+) require a logged in user.
pt: Os que estão marcados com um (+) requerem um usuário conectado.

en: Auth UI
pt: Interface de autenticação

en: You can create your own web UI to login users using the above APIs but py4web provides one as an example, implemented in the following files:
pt: Você pode criar sua própria interface do usuário da web para usuários de login usando as APIs acima, mas py4web fornece um como exemplo, implementada nos seguintes arquivos:

en: \_scaffold/templates/auth.html
pt: \ _Scaffold / templates / auth.html

en: \_scaffold/static/components/auth.js
pt: \ _scaffold / static / componentes / auth.js

en: \_scaffold/static/components/auth.html
pt: \ _Scaffold / static / componentes / auth.html

en: The component files (js/html) define a Vue component ``<auth/>`` which is used in the template file auth.html as follows:
pt: Os arquivos do componente (js / html) definem um componente Vue `` <auth /> `` que é usado na auth.html arquivo de modelo da seguinte forma:

en: You can pretty much use this file un-modified. It extends the current layout and embeds the ``<auth/>`` component into the page. It then uses ``utils.app().start();`` (py4web magic) to render the content of ``<div id="vue">...</div>`` using Vue.js. ``components/auth.js`` also automatically loads ``components/auth.html`` into the component placeholder (more py4web magic). The component is responsible for rendering the login/register/etc forms using reactive html and GETing/POSTing data to the Auth service APIs.
pt: Você pode muito bem usar esse arquivo modificado-un. Estende-se o layout atual e incorpora o `` <auth /> `` componente na página. Em seguida, usa `` utils.app () start ();. `` (Magia py4web) para processar o conteúdo de `` <div id = "vue"> ... </ div> `` usando Vue.js. `` componentes / auth.js`` também carrega automaticamente `` componentes / auth.html`` para o espaço reservado componente (mais mágicas py4web). O componente é responsável para render o login / registo / etc formas usando reactivo html e Geting / dados de lançamento com a API de serviço de autenticação.

en: If you need to change the style of the component you can edit “components/auth.html” to suit your needs. It is mostly HTML with some special Vue ``v-*`` tags.
pt: Se você precisa mudar o estilo do componente que você pode editar “componentes / auth.html” para atender às suas necessidades. É principalmente HTML com algum especial Vue `` v- * `` tags.

en: Using Auth
pt: Usando o Auth

en: There two ways to use the Auth object in an action:
pt: Há duas maneiras de usar o objeto Auth em uma ação:

en: With ``@action.uses(auth)`` we tell py4web that this action needs to have information about the user, then try to parse the session for a user session.
pt: Com `` @ action.uses (auth) `` nós dizemos py4web que esta ação precisa ter informações sobre o usuário, em seguida, tentar analisar a sessão para uma sessão de usuário.

en: Here ``@action.uses(auth.user)`` tells py4web that this action requires a logged in user and should redirect to login if no user is logged in.
pt: Aqui `` @ action.uses (auth.user) `` diz py4web que essa ação requer um usuário conectado e deve redirecionar para login se nenhum usuário está logado.

en: Auth Plugins
pt: Plugins de Autenticação

en: Plugins are defined in “py4web/utils/auth_plugins” and they have a hierachical structure. Some are exclusive and some are not. For example, default, LDAP, PAM, and SAML are exclusive (the developer has to pick one). Default, Google, Facebook, and Twitter OAuth are not exclusive (the developer can pick them all and the user gets to choose using the UI).
pt: Plugins são definidos no “py4web / utils / auth_plugins” e eles têm uma estrutura hierárquica. Alguns são exclusivos e alguns não são. Por exemplo, padrão, LDAP, PAM, e SAML são exclusivos (o desenvolvedor tem que escolher um). Padrão, o Google, Facebook e Twitter OAuth não são exclusivos (o desenvolvedor pode pegar todos eles e que o usuário começa a escolher usando a interface do usuário).

en: The ``<auth/>`` components will automatically adapt to display login forms as required by the installed plugins.
pt: O `` <auth /> `` componentes irá se adaptar automaticamente para formulários de login de exibição, conforme exigido pelos plugins instalados.

en: **At this time we cannot guarantee that the following plugins work well. They have been ported from web2py where they do work but testing is still needed**
pt: ** Neste momento, não podemos garantir que os seguintes plugins funcionam bem. Eles foram portados de web2py onde eles não funcionam, mas o teste ainda é necessária **

en: Configuring PAM is the easiest:
pt: Configurando PAM é o mais fácil:

en: This one like all plugins must be imported and registered. Once registered the UI (components/auth) and the RESTful APIs know how to handle it. The constructor of this plugins does not require any arguments (where other plugins do).
pt: Este, como todos os plugins deve ser importado e registrado. Uma vez registrado o UI (componentes / auth) e as APIs RESTful sabe como lidar com isso. O construtor desta plugins não requer quaisquer argumentos (onde outros plugins fazer).

en: The ``auth.register_plugin(...)`` **must** come before the ``auth.enable()`` since it makes no sense to expose APIs before desired plugins are mounted.
pt: O `` auth.register_plugin (...) `` must ** ** vir antes do `` auth.enable () ``, uma vez que não faz sentido para expor APIs antes de plugins desejados são montados.

en: OAuth2 with Google (tested OK)
pt: OAuth2 com Google (testado OK)

en: The client id and client secret must be provided by Google.
pt: O ID de cliente e segredo do cliente deve ser fornecido pelo Google.

en: OAuth2 with Facebook (tested OK)
pt: OAuth2 com Facebook (testado OK)

en: The client id and client secret must be provided by Facebook.
pt: O ID de cliente e segredo do cliente deve ser fornecido pelo Facebook.

en: Tags and Permissions
pt: Etiquetas e permissões

en: Py4web does not have the concept of groups as web2py does. Experience showed that while that mechanism is powerful it suffers from two problems: it is overkill for most apps, and it is not flexible enough for very complex apps. Py4web provides a general purpose tagging mechanism that allows the developer to tag any record of any table, check for the existence of tags, as well as checking for records containing a tag. Group membership can be thought of a type of tag that we apply to users. Permissions can also be tags. Developer are free to create their own logic on top of the tagging system.
pt: O Py4web não tem o conceito de grupos como web2py. A experiência mostrou que, enquanto esse mecanismo é poderoso ele sofre de dois problemas: é um exagero para a maioria dos aplicativos, e não é suficiente flexível para aplicativos muito complexos. Py4web fornece um mecanismo de marcação de uso geral que permite ao desenvolvedor tag qualquer registro de qualquer tabela, verificar a existência de marcas, bem como a verificação de registros contendo uma tag. associação de grupo pode ser considerado um tipo de tag que se aplicam aos usuários. As permissões também pode ser tags. Desenvolvedor é livre para criar sua própria lógica no topo do sistema de marcação.

en: To use the tagging system you need to create an object to tag a table:
pt: Para usar o sistema de marcação, você precisa criar um objeto para marcar uma tabela:

en: Then you can add one or more tags to records of the table as well as remove existing tags:
pt: Então você pode adicionar uma ou mais marcas de registros da tabela, bem como remover existente tags:

en: Here the use case is group based access control where the developer first checks if a user is a member of the ``'manager'`` group, if the user is not a manager (or no one is logged in) py4web redirects to the ``'not authorized url'``. If the user is in the correct group then py4web displays ‘hello manager’:
pt: Aqui, o caso de uso é o controle de acesso baseado em grupo, onde o desenvolvedor primeiro verifica se um usuário é um membro do "grupo` `manager'``, se o usuário não é um administrador (ou ninguém está logado) redirecionamentos py4web ao `` 'não autorizada url'``. Se o usuário estiver no grupo correto, então manager Olá 'py4web exibe:

en: Here the developer queries the db for all records having the desired tag(s):
pt: Aqui o desenvolvedor consulta o banco de dados para todos os registros que têm a tag desejada (s):

en: We leave it to you as an exercise to create a fixture ``has_membership`` to enable the following syntax:
pt: Deixamos para você como um exercício para criar um dispositivo elétrico `` has_membership`` para permitir a seguinte sintaxe:

en: **Important:** ``Tags`` are automatically hierarchical. For example, if a user has a group tag ‘teacher/high-school/physics’, then all the following seaches will return the user:
pt: ** Importante: ** `` Tags`` são automaticamente hierárquica. Por exemplo, se um usuário tem um grupo tag ‘professor /-ensino médio / física’, em seguida, todas as seguintes seaches retornará o usuário:

en: ``groups.find('teacher/high-school/physics')``
pt: `` Groups.find ( 'professor /-ensino médio / física') ``

en: ``groups.find('teacher/high-school')``
pt: `` Groups.find ( 'professor /-colegial') ``

en: ``groups.find('teacher')``
pt: `` Groups.find ( 'professor') ``

en: This means that slashes have a special meaning for tags. Slahes at the beginning or the end of a tag are optional. All other chars are allowed on equal footing.
pt: Isto significa que as barras têm um significado especial para tags. Slahes no início ou no final de uma tag são opcionais. Todos os outros caracteres são permitidos em pé de igualdade.

en: Notice that one table can have multiple associated ``Tags`` objects. The name groups here is completely arbitary but has a specific semantic meaning. Different ``Tags`` objects are orthogonal to each other. The limit to their use is your creativity.
pt: Observe que uma tabela pode ter vários associados `` Tags`` objetos. Os grupos nome aqui é completamente arbitrária, mas tem um significado semântico específico. Diferentes `` objectos Tags`` são ortogonais entre si. O limite para o seu uso é a sua criatividade.

en: For example you could create a table groups:
pt: Por exemplo, você poderia criar um grupos de mesa:

en: and to Tags:
pt: e Tags:

en: Then create a zapper group, give it a permission, and make a user member of the group:
pt: Em seguida, crie um grupo zapper, dar-lhe uma permissão, e tornar um membro do usuário do grupo:

en: And you can check for a user permission via an explicit join:
pt: E você pode verificar se há uma permissão de utilizador através de uma junção explícita:

en: Notice here ``permissions.find(permission)`` generates a query for all groups with the permission and we further filter those groups for those the current user is member of. We count them and if we find any, then the user has the permission.
pt: Aviso aqui `` permissions.find (permissão) `` gera uma consulta para todos os grupos com a permissão e que ainda filtro desses grupos para aqueles do utilizador actual é membro da. Contamos eles e se encontrarmos qualquer, então o usuário tem a permissão.
