php bin/console debug/container log 

$this->addSql('ALTER TABLE pages CHANGE title_txtid title_txtid INT DEFAULT NULL');

doctrine:schema:update —force

doctrine:migrations:diff

doctrine:migrations:migrate.

public function deleteAllTransportsByCountry($countryId) {
        return $this->createQueryBuilder('countryTransport')
            ->delete('Model:CountryTransport', 's')
            ->where('s.countryId = :countryId')
            ->setParameter('countryId', $countryId)
            ->getQuery()
            ->execute();
    }

$em->getRepository('Model:CountryTransport')->deleteAllTransportsByCountry($country->getId());

class User
{
  /**
  * Many Users have Many Groups.
  * @ORM\ManyToMany(targetEntity="Group", inversedBy="users")
  * @ORM\JoinTable(name="roles_users")
  */
  private $roles;

  public function __construct() {
    $this->roles = new ArrayCollection();
  }

class Role
{
  /**
  * Many Roles have Many Users.
  * @ORM\ManyToMany(targetEntity="User", mappedBy="roles")
  */
  private $users;

  public function __construct() {
    $this->users = new ArrayCollection();
  }

<li><a>Количество ролей <span class="pull-right badge bg-blue">{{ user.roles.count }}</span></a></li>

$isNotChanged = ($roles == $userRoles);
       if(!$isNotChanged ) {
           if ( !empty($requestResultArr['id'])) {
               $this->getDoctrine()->getRepository('Model:RoleUser')->clearRoles($user->getId());
           }
           foreach ($roles as $role) {
               $roleModel = $em->getRepository('Model:Role')->findOneBy(['name' => $role]);
               $user->addRole($roleModel);
               $em->persist($roleModel);
           }
       }
        $em->persist($user);
        $em->flush();

$recentNotes = $genus->getNotes()->filter(function (GenusNote $note){
return $note->getCreatedAt() > new \DateTime('-3 month');
});

$transformer = $this->get('app.markdown_transformer');

return [
new \Twig_SimpleFilter('markdownify', [$this, 'parseMarkdown'])
];

app.markdown_extension:
class: AppBundle\Twig\MarkdownExtension
tags:
- { name: twig.extension}
arguments: ['@app.markdown_transformer']

return $this->markdownTransformer->parse($str);

{{ forms.multilang(
['Заголовок страницы', 'Мета-теги', 'Содержание страницы'],
{'title': 'input', 'meta': 'input', 'text': 'text'},
[page.title, page.meta, page.text]
) }}

public function getValueByKey($value, $key)
    {
        return $value[$key];
    }

    return $this->render('admin/subscriber/index.html.twig');

 $listsHotTours = $this->getDoctrine()->getRepository('Model:BlockHottour')->findAll();
        $listsItems = array_map(function ($item) {
            /** @var BlockHottour $item */
            return [
                $item->getDestinationType() == 'country' ? 'Страна' : 'Курорт',
                $item->getDestinationType() == 'country' ? $item->getCountry()->getName() : $item->getCity()->getName(),
                $item->getSortOrder(),
                $item->getActive() ? '<span class="text-success">Активен' : '<span class="text-warning">Неактивен',
                HTML::tag('div', implode('', [
                    HTML::tag('a', 'Редактировать', ['class' => 'btn btn-flat btn-primary', 'href' => $this->generateUrl('Admin_UpdateHottour', ['id' => $item->getId()])]),
                ]), ['class' => 'btn-group btn-group-sm'])
            ];
        }, $listsHotTours);
        return new JsonResponse(['answer' => $listsItems, 'status_ok' => true]);

$data = $this->getDataArrayFromRequest($request);
        if (isset($data['image'])) {
            $this->saveImages(OfficeImage::class, $data['image'], Office::class, $data['id']);
        }

 protected function getDataArrayFromRequest(Request $request)
    {
        return json_decode($request->getContent(), true);
    }

 public function saveImages($modelName, $images, $mainModelName, $mainModelId)
    {
            foreach ($images as $image) {
                $imageId = $this->getDoctrine()->getRepository('Model:Image')->getLastId();
                $saved = $this->get('app.image')->addNewImageBase64($image, $imageId);
                if($saved) { $this->save(new Image()); }
                $model = new $modelName();
                $imageModel = $this->getDoctrine()->getRepository('Model:Image')->find($imageId);
                $mainModel = $this->getDoctrine()->getRepository($mainModelName)->find($mainModelId);
                $model->setImage($imageModel);
                $key = 'set' . substr(strrchr($mainModelName, '/'), 1);
                $model->$key($mainModel);
                $this->save($model);
            }
    }
    

 $model = $this->factory($id, Morfer::class);

 protected function factory($id, $repo)
    {
        /** @var BaseEntity $model */
        if (!empty($id)) {
            $model = $this->getDoctrine()->getRepository($repo)->find($id);
        } else {
            $model = new $repo();
        }
      //  Also can be used in more elegant way
      //  $model = empty($id) ? new $repo() : $this->getDoctrine()->getRepository($repo)->find($id);
        return $model;
    }
    

public function saveAction(Request $request) {
        $data = $this->getDataArrayFromRequest($request);
        $model = $this->factory($data['id'], Morfer::class);
        $this->save($model->trustValues($data));
        return new JsonResponse(['data' => $data]);
    }
    

public function trustValues($values) {
        foreach ($values as $field => $val) {
                $method = 'set' . ucfirst($field);
                if(method_exists($this, $method)) {
                    $this->$method($values[$field]);
                }
        }
       return $this;
    }
    

 public function values($values, $fields, $relationBindingModels = [])
    {
        foreach ($fields as $field) {
            if (isset($values[$field])) {
                $method = 'set' . ucfirst($field);
                $this->$method($values[$field]);
            }
        }
        if (count($relationBindingModels) > 0) {
            foreach ($relationBindingModels as $name => $model) {
                $method = 'set' . ucfirst($name);
                $this->$method($model);
            }
        }
        return $this;
    }
    

$model->values($data, 
['active', 'h1', 'metaDescription', 'metaKeywords', 'metaTitle', 'text', 'title'], 
['country' => $country]);

$migration->createTable($schema, 'landing_countries_translation', ['meta_title', 'meta_description', 'meta_keywords', 'html_text']);

    /**
     * @param Schema $schema
     * @param string $table Name of the new table
     * @param array $translatableFields list of fields
     */
    public function createTable(Schema &$schema, $table, $translatableFields) {
        if(!$schema->hasTable($table)) {
            $mainTable = explode('_', $table)[0];
            $tableNewSchema = $schema->createTable($table);
            $tableNewSchema->addColumn('id', Type::INTEGER, [
                'autoincrement' => true,
            ]);
            $tableNewSchema->setPrimaryKey(['id']);
            $tableNewSchema->addColumn('translatable_id', Type::INTEGER, [
                'notnull' => false
            ]);
            $tableNewSchema->addIndex(['translatable_id'], 'idx_'.$table);
            foreach ($translatableFields as $translatableField) {
                if (strpos($translatableField, '_text') !== false) {
                    $translatableField = str_replace('_text', '', $translatableField);
                    $tableNewSchema->addColumn($translatableField, Type::TEXT, [
                        'notnull' => false
                    ]);
                } else {
                    $tableNewSchema->addColumn($translatableField, Type::STRING, [
                        'notnull' => false
                    ]);
                }
            }
            $tableNewSchema->addColumn('locale', Type::STRING, [
                'length' => 2,
                'notnull' => true
            ]);
        }
    }

        $dd = $this;
        $func = function($query) use (&$dd) {
            $dd->addSql($query);
        };
        $migration->writeInDataIntoTranslatable($schema, 'landing_countries_translation', ['meta_title', 'meta_description', 'meta_keywords', 'html'], $func);

$obj("INSERT INTO {$schema->getName()}.{$table} ( ...

    /**
     * @ORM\ManyToOne(targetEntity="Model\Entity\Slide", inversedBy="tranlations")
     * @ORM\JoinColumn(name="translatable_id", referencedColumnName="id")
     */
    private $transtable;

 /**
     * @ORM\OneToMany(targetEntity="Model\Entity\SlideTranslation", mappedBy="transtable")
     * @ORM\JoinColumn(name="id", referencedColumnName="translatable_id")
     */
    private $tranlations;

    public function __construct() {
        $this->tranlations = new ArrayCollection();
    }
    

 protected function factory($id, $repo, $namespace = null)
    {
        /** @var BaseEntity $model */
        if (!empty($id)) {
            $model = $this->getDoctrine()->getRepository('Model:' . $repo)->find($id);
        } else {
            if (isset($namespace)) {
                $repo = $namespace . $repo;
                $model = new $repo();
                $model->setTranslate($repo . 'Translation');
            } else {
                $repo = 'Model\Entity\\' . $repo;
                $model = new $repo();
                $model->setTranslate($repo . 'Translation');
                if (class_exists($model->getTranslate())) {
                    $langs = Config::load('lang.short');
                    $count = count($langs);
                    for ($i = 0; $i < $count; $i++) {
                        $translationModelName = $model->getTranslate();
                        /** @var BaseEntity $translationModel */
                        $translationModel = new $translationModelName();
                        $translationModel->setLocale($langs[$i]);
                        $model->addTranslationModel($translationModel);
                    }
                }
            }
        }
        return $model;
    }
    

$this->setTranslation(__FUNCTION__, $value);

 public function setTranslation($functionName, $data)
    {
        try {
            $translations = lcfirst(str_replace('set', '', $functionName)) . 'Translation';
           if(isset($this->$translations)) {
                   foreach ($this->$translations as $translation) {
                       foreach ($data as $lang => $text) {
                           if ($translation->getLocale() == $lang) {
                               $translation->$functionName($text);
                           }
                       }
                   }
           } else {
               foreach ($this->getTranslationModels() as $translation) {
                   foreach ($data as $lang => $text) {
                       if ($translation->getLocale() == $lang) {
                           $translation->$functionName($text);
                       }
                   }
               }

           }

        } catch (\Exception $e) {
            throw new Exception($e->getMessage());
        }
    }

 $transTable = $entity->getTranslationModels();
            $em->persist($entity);
            $em->flush();
            /** @var BaseEntity $model */
            foreach ($transTable as $model) {
                $model->setTranstable($entity);
                $em->persist($model);
                $em->flush();
            }

/**
     * @Route("/login", name="login")
     */
    public function loginAction() {
        $authenticationUtils = $this->get('security.authentication_utils');

        // get the login error if there is one
        $error = $authenticationUtils->getLastAuthenticationError();

        // last username entered by the user
        $lastUsername = $authenticationUtils->getLastUsername();

        $form = $this->createForm(LoginForm::class, [
            '_username' => $lastUsername
        ]);
        return $this->render('security/login.html.twig', array(
            'form' => $form->createView(),
            'error'         => $error,
        ));
    }

namespace AppBundle\Security;


use AppBundle\FormType\LoginForm;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Guard\Authenticator\AbstractFormLoginAuthenticator;

class LoginFormAuthenticator extends AbstractFormLoginAuthenticator
{

    /**
     * @var FormFactoryInterface
     */
    private $formFactory;
    /**
     * @var EntityManager
     */
    private $em;
    /**
     * @var RouterInterface
     */
    private $router;

    public function __construct(FormFactoryInterface $formFactory, EntityManager $entityManager, RouterInterface $router)
     {

         $this->formFactory = $formFactory;
         $this->em = $entityManager;
         $this->router = $router;
     }

    public function getCredentials(Request $request)
     {
            $isLoginSubmit = $request->getPathInfo() == '/login' && $request->isMethod('POST');
            if (!$isLoginSubmit) {
                    return null;
         }
         $form = $this->formFactory->create(LoginForm::class);
         $form->handleRequest($request);
         $data = $form->getData();
         return $data;

     }

     public function getUser($credentials, UserProviderInterface $userProvider)
     {
            $username = $credentials['_username'];
            return $this->em->getRepository('AppBundle:User')->findOneBy(['email' => $username]);
     }

     public function checkCredentials($credentials, UserInterface $user)
     {
           $password = $credentials['_password'];

           if($password == 'ilike') {
                   return true;
        }
        return false;
     }

     protected function getLoginUrl()
     {
            return $this->router->generate('login');
     }
     protected function getDefaultSuccessRedirectUrl() {
            $this->router->generate('genus_notes');
        }


 }

$request->getSession()->set(
            Security::LAST_USERNAME, $data['_username']
        );

throw new \Exception('this should not be reached');

public function setPlainPassword($plainPassword)
     {
         $this->plainPassword = $plainPassword;
         $this->password = null;
     }
     
     public function eraseCredentials()
      {
        $this->plainPassword = null;
      }
     

namespace AppBundle\Doctrine;


use AppBundle\Entity\User;
use Doctrine\Common\EventSubscriber;
use Doctrine\ORM\Event\LifecycleEventArgs;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoder;

class HashPasswordListener implements EventSubscriber
{

    /**
     * @var UserPasswordEncoder
     */
    private $passwordEncoder;

    public function __construct(UserPasswordEncoder $passwordEncoder)
    {
        $this->passwordEncoder = $passwordEncoder;
    }

    public function prePersist(LifecycleEventArgs $args) {
        $entity = $args->getEntity();
        if(!$entity instanceof User) {
            return;
        }
      $this->encodePassword($entity);
    }
    public function preUpdate(LifecycleEventArgs $args) {
        $entity = $args->getEntity();
        if(!$entity instanceof User) {
            return;
        }
        $this->encodePassword($entity);
        $em = $args->getEntityManager();
        $meta = $em->getClassMetadata(get_class($entity));
        $em->getUnitOfWork()->recomputeSingleEntityChangeSet($meta, $entity);
    }

    public function getSubscribedEvents()
    {
        return ['prePersist', 'preUpdate'];
    }

    /**
     * @param User $entity
     */
    private function encodePassword(User $entity) {
        $encoded = $this->passwordEncoder->encodePassword($entity, $entity->getPlainPassword());
        $entity->setPassword($encoded);
    }
}

use Symfony\Component\Security\Core\Encoder\UserPasswordEncoder

if($this->passwordEncoder->isPasswordValid($user, $password)) {
           return true;
       }

  /**
    * @ORM\Column(type="json_array")
    */
    private $roles = [];
    .......
    
$roles = $this->roles;
        if(!in_array('ROLE_USER', $roles)) {
             $roles[] = 'ROLE_USER';
        }
        return $roles;

 return $this->get('security.authentication.guard_handler')->authenticateUserAndHandleSuccess(
              $user,
              $request,
              $this->get('app.security.login_form_authenticator'),
              'main'
            );

namespace Admin\Doctrine;

use Symfony\Component\Templating\EngineInterface;
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
use Symfony\Component\HttpFoundation\RedirectResponse;

class RedirectListener
{
    protected $templating;

    public function __construct(EngineInterface $templating)
    {
        $this->templating = $templating;
    }

    public function onKernelResponse(FilterResponseEvent $event)
    {
        $response = $event->getResponse();

        if (!($response instanceof RedirectResponse)) {
            return;
        }

        $uri  = $response->getTargetUrl();
        $html = $this->templating->render(
            '301.html.twig',
            array('uri' => $uri)
        );

        $response->setContent($html);
    }
}

namespace Admin\Doctrine;


use Doctrine\ORM\EntityManager;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\HttpKernel\HttpKernel;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;

class RequestListener
{
    private $em;
    private $token;
    public function __construct(EntityManager $em, TokenStorage $token)
    {
        $this->em = $em;
        $this->token = $token;
    }

    public function onKernelRequest(GetResponseEvent $event)
    {
        if (strpos($event->getRequest()->getUri(), '/admin') !== false) {
// some actions
        } else {
            return;
        }
    }
}

        $client = static::createClient();
        $container = $client->getContainer();
       
       // или альтернативный способ
        $container = self::$container;

public function setUp()
    {
        $this->guzzle = new Client(
            [
                'base_uri' => self::$container->getParameter('uri'),
                'verify'   => false
            ]
        );
    }

 protected function invokeMethod(string $methodName, array $data)
    {
        $reflection = new \ReflectionClass(get_class($this->util));
        $method = $reflection->getMethod($methodName);
        $method->setAccessible(true);

        return $method->invokeArgs($this->util, $data);
    }

public function tearDown()
    {
        gc_collect_cycles();
    }

    /**
     * @covers ManagerVoipController::login()
     */

    /**
     * @depends testActiveDepends
     */

$input = ['name' => 'value'];
$output = isset($input['key']) ?: isset($input['name']) ? 'yes' : 'no';

var_dump($output); // yes