Виктор П.

var logger = _servicesProvider.GetRequiredService<ILogger<ConsumerHostedService<Entity>>() as FakeConsumerHostedServiceLogger;
var msgs = logger.messages;

render(
      <MemoryRouter initialEntries={["/epic/details?id=1"]}>
        <Routes>
          <Route path="/epic/details" element={<DetailsPage />} />
        </Routes>
      </MemoryRouter>
    );

import UserModel from "../models/user.model";
import React from "react";

const UserService = () => {
  const localStorageKey = "user";
  const [user, setStateUser] = React.useState<UserModel | null>(null);

  function getUser(): UserModel | null {
    if (user != null) return user;

    const usr = localStorage.getItem(localStorageKey);
    if (usr != null) setStateUser(new UserModel(JSON.parse(usr)));

    return user;
  }

  function setUser(val: UserModel) {
    localStorage.setItem(localStorageKey, JSON.stringify(val));
    setStateUser(val);
  }

  function logOut(){
    localStorage.removeItem(localStorageKey);
    setStateUser(null);
  }

  function isAuth(): boolean {
    return user != null && user.userName != null;
  }

  function hasRole(roleId: number): boolean {
    if (!user || !isAuth || user.roles == null) return false;
    return user.roles.indexOf(roleId) > -1;
  }

  return{
    getUser,
    setUser,
    logOut,
    isAuth,
    hasRole
  }
}

export default UserService;

import React, { useContext } from "react";
import UserService from "../services/user.service";

const userContext = React.createContext(null);

export const UserProvider = ({ children }: any) => {
  const userService = UserService();

  return (
    <userContext.Provider value={userService}>
      {children}
    </userContext.Provider>
  );
};

export const useUser = () => useContext(userContext);

using CartCalculator.Models;

namespace CartCalculator;

public class Calculator
{
    private readonly Product[] _allMenuProducts;
    private readonly Promocode[] _allAvailablePromocodes;
    private readonly DeliveryZone[] _allDeliveryZones;

    public Calculator(Product[] allMenuProducts, Promocode[] allAvailablePromocodes, DeliveryZone[] allDeliveryZones)
    {
        _allMenuProducts = allMenuProducts;
        _allAvailablePromocodes = allAvailablePromocodes;
        _allDeliveryZones = allDeliveryZones;
    }

    public double CalculateTotalPrice(Cart cart)
    {
        double totalPrice = 0;

        ICalculationStep[] steps =
        {
            new ProductsSumStep(_allMenuProducts),
            new PromoCodeStep(_allAvailablePromocodes),
            new DeliveryFeeStep(_allDeliveryZones),
        };

        foreach (var step in steps)
        {
            totalPrice = step.Calculate(cart, totalPrice);
        }

        return totalPrice;
    }
}

using System.Diagnostics.Metrics;

namespace MyProject.Outbox;

public class OutboxMetrics
{
    private readonly IOutboxRepository _repository;
    public static readonly Meter OutboxMeter = new("Outbox");
    public readonly Counter<int> OutboxPublishCounter = OutboxMeter.CreateCounter<int>("outbox-publish");

    public OutboxMetrics(IOutboxRepository repository)
    {
        _repository = repository;

        OutboxMeter.CreateObservableGauge<long>("outbox-count", () => GetOutboxLength);
    }

    private long GetOutboxLength => _repository.GetLength().GetAwaiter().GetResult();
}

builder.Services.AddControllers()
    .ConfigureApiBehaviorOptions(options =>
    {
        options.SuppressConsumesConstraintForFormFileParameters = true;
        options.SuppressInferBindingSourcesForParameters = true;
        options.SuppressModelStateInvalidFilter = true; // вот это
        options.SuppressMapClientErrors = true;
        options.ClientErrorMapping[StatusCodes.Status404NotFound].Link =
            "https://httpstatuses.com/404";
    });