import org.codelibs.fess.opensearch.config.exentity.AccessToken;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.RenderDataUtil;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;

				err = msgp.WrapError(err, "Tiers")
				return
			}
			if z.Tiers == nil {
				z.Tiers = make(map[string]madmin.TierConfig, zb0002)
			} else if len(z.Tiers) > 0 {
				for key := range z.Tiers {
					delete(z.Tiers, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 madmin.TierConfig
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Tiers")

        try {
            searchEngineClient.deleteByQuery(fessConfig.getIndexDocumentUpdateIndex(), queryBuilder);

        } catch (final Exception e) {
            logger.error("Could not delete expired documents: {}", queryBuilder, e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();
    }

But that is still not that useful.

Let's make it give us the current user.

## Create a user model { #create-a-user-model }

First, let's create a Pydantic user model.

The same way we use Pydantic to declare bodies, we can use it anywhere else:

{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:6] *}

## Create a `get_current_user` dependency { #create-a-get-current-user-dependency }

При создании API, "путь" является основным способом разделения "задач" и "ресурсов".

#### Операция (operation)

"Операция" это один из "методов" HTTP.

Таких, как:

* `POST`
* `GET`
* `PUT`
* `DELETE`

...и более экзотических:

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

По протоколу HTTP можно обращаться к каждому пути, используя один (или несколько) из этих "методов".

---

            "type" : "long"
          },
          "virtualHost" : {
            "type" : "keyword"
          }
        }
      }
    },
    "settings" : {
      "index" : {
        "dbflute" : {
          "related_query" : {
            "properties" : {
              "queries" : {
                "array" : "true"
              }
            }
          }
        },

 * }
 *
 * <p>Graph algorithms that need additional capabilities (accessing both predecessors and
 * successors, iterating over the edges, etc.) should declare their input to be of a type that
 * provides those capabilities, such as {@link Graph}, {@link ValueGraph}, or {@link Network}.
 *
 * <h3>Additional documentation</h3>
 *

Apart from all the fancy words used here, the **Dependency Injection** system is quite simple.

Just functions that look the same as the *path operation functions*.

But still, it is very powerful, and allows you to declare arbitrarily deeply nested dependency "graphs" (trees).

/// tip

All this might not seem as useful with these simple examples.

But you will see how useful it is in the chapters about **security**.

{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}

## Description from docstring { #description-from-docstring }

As descriptions tend to be long and cover multiple lines, you can declare the *path operation* description in the function <abbr title="a multi-line string as the first expression inside a function (not assigned to any variable) used for documentation">docstring</abbr> and **FastAPI** will read it from there.

            // Arrange
            doReturn(false).when(smbFile).exists();
            doThrow(new SmbException("File not found")).when(smbFile).delete();

            // Act & Assert
            assertThrows(SmbException.class, () -> smbFile.delete());
        }

        @Test
        void testMkdirWhenDirectoryExists() throws SmbException, CIFSException {
            // Arrange