Você receberá um erro "Usuário inativo", como:

```JSON
{
  "detail": "Inactive user"
}
```

## Recaptulando

Agora você tem as ferramentas para implementar um sistema de segurança completo baseado em `username` e `password` para sua API.

Usando essas ferramentas, você pode tornar o sistema de segurança compatível com qualquer banco de dados e com qualquer usuário ou modelo de dados.

O mais comum é o fluxo implícito.

O mais seguro é o fluxo de código, mas ele é mais complexo para implementar, pois ele necessita mais passos. Como ele é mais complexo, muitos provedores terminam sugerindo o fluxo implícito.

/// note | "Nota"

///

### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a>

Hug foi um dos primeiros frameworks a implementar a declaração de tipos de parâmetros usando Python _type hints_. Isso foi uma ótima idéia que inspirou outras ferramentas a fazer o mesmo.

This is preferred:

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}
```

This is acceptable:

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}

abstract class DefaultNewThing implements NewThing {

   * @throws UnsupportedOperationException if backward conversion is not implemented; this should be
   *     very rare. Note that if backward conversion is not only unimplemented but
   *     unimplement<i>able</i> (for example, consider a {@code Converter<Chicken, ChickenNugget>}),
   *     then this is not logically a {@code Converter} at all, and should just implement {@link
   *     Function}.
   */
  @ForOverride

   * as {@code execute} and {@code invokeAny}, are implemented in terms of calls to {@code
   * delegate.execute}. All other methods are forwarded unchanged to the delegate. This implies that
   * the returned {@code ListeningExecutorService} never calls the delegate's {@code submit}, {@code
   * invokeAll}, and {@code invokeAny} methods, so any special handling of tasks must be implemented

   * @throws IllegalArgumentException if {@code count} is negative
   * @throws NullPointerException if {@code element} is null and this implementation does not permit
   *     null elements. Note that if {@code count} is zero, the implementor may optionally return
   *     zero instead.
   */
  @CanIgnoreReturnValue
  int setCount(@ParametricNullness E element, int count);

  /**

   * @throws IllegalArgumentException if {@code count} is negative
   * @throws NullPointerException if {@code element} is null and this implementation does not permit
   *     null elements. Note that if {@code count} is zero, the implementor may optionally return
   *     zero instead.
   */
  @CanIgnoreReturnValue
  int setCount(@ParametricNullness E element, int count);

  /**

   *   <li>{@code hash(null)} is {@code 0}.
   * </ul>
   */
  public final int hash(@CheckForNull T t) {
    if (t == null) {
      return 0;
    }
    return doHash(t);
  }

  /**
   * Implemented by the user to return a hash code for {@code t}, subject to the requirements
   * specified in {@link #hash}.
   *
   * <p>This method should not be called except by {@link #hash}. When {@link #hash} calls this

    return errors::Unimplemented(
        "Registering graph functions has not been implemented yet.");
  }

  absl::Status RemoveFunction(const string& func) override {
    return errors::Unimplemented(
        "GraphContext::RemoveFunction has not been implemented yet.");
  }
  // For LLVM style RTTI.
  static bool classof(const AbstractContext* ptr) {