Http basic auth with FOSUserBundle

app-config-config.yml

fos_user:
    db_driver: orm
    firewall_name: main
    user_class: Company\YourBundle\Entity\User

app-config-routing.yml

# Root

root:
    pattern: /
    defaults:
        _controller: FrameworkBundle:Redirect:urlRedirect
        path: http://www.yourdomain.de
        permanent: true
    methods: [GET]

# Backend

company_backend:
    resource: "@CompanyBackendBundle/Resources/config/routing.yml"
    prefix:   /

# Admin Interface

admin:
    resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
    prefix: /admin

_sonata_admin:
    resource: .
    type: sonata_admin
    prefix: /admin

# User Management

fos_user_security:
    resource: "@FOSUserBundle/Resources/config/routing/security.xml"

fos_user_profile:
    resource: "@FOSUserBundle/Resources/config/routing/profile.xml"
    prefix: /profile

fos_user_register:
    resource: "@FOSUserBundle/Resources/config/routing/registration.xml"
    prefix: /register

fos_user_resetting:
    resource: "@FOSUserBundle/Resources/config/routing/resetting.xml"
    prefix: /resetting

fos_user_change_password:
    resource: "@FOSUserBundle/Resources/config/routing/change_password.xml"
    prefix: /profile

app-config-security.yml

security:
    encoders:
        FOS\UserBundle\Model\UserInterface: sha512

    role_hierarchy:
        ROLE_USER:            ROLE_USER
        ROLE_ADMIN:           ROLE_ADMIN
        ROLE_DEV:             ROLE_DEV

    providers:
        fos_userbundle:
            id: fos_user.user_provider.username

    firewalls:
        registration:
            pattern: ^/registration
            anonymous: true
        api:
            pattern: ^/v/
            http_basic:
                realm: "API"
                provider: fos_userbundle
        main:
            pattern: ^/
            form_login:
                provider: fos_userbundle
                csrf_provider: form.csrf_provider
                login_path: /login
                check_path: /login_check
                default_target_path: /admin/dashboard
            logout:
                path:   /logout
                target: /login
            anonymous: true

    access_control:
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/, role: ROLE_ADMIN }
        - { path: ^/api/, role: ROLE_USER }

src-Company-Bundle-BackendBundle-Controller-UserController.php

<?php

namespace Company\BackendBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;
use Doctrine\DBAL\DBALException;
use JMS\Serializer\SerializationContext;
use Symfony\Component\HttpFoundation\Request;

use Company\BackendBundle\Entity\User;

class UserController extends Controller
{
    public function createAction()
    {
        $request = $this->getRequest();

        $email = $request->get("email");
        $password = $request->get("password");

        // Exit if not all parameters are set
        if(empty($email) || empty($password)) {
            return new Response("Parameters can't be empty", 400);
        }

        try {
            $user = $this->createUser($email, $password, $request);
            return $this->createSerializedJsonResponse($user);
        } catch (DBALException $e) {
            return new Response("A user with this email already exists", 400);
        }
    }

    public function updateAction()
    {
        $request = $this->getRequest();

        /** @var $user User */
        $user = $this->getUser();

        $user = $this->updateUser($user, $request);

        return $this->createSerializedJsonResponse($user);
    }

    /**
     * Login is handled via symfony http authentication. Just provide an endpoint to call
     *
     * @return integer
     */
    public function loginAction()
    {
        /** @var $user User */
        $user = $this->getUser();
        $request = $this->getRequest();

        $user = $this->updateUserOnLogin($user, $request);

        return $this->createSerializedJsonResponse($user, array('user'));
    }

    private function createUser($email, $password, Request $request)
    {
        $userManager = $this->getUserManager();
        /** @var $user User */
        $user = $userManager->createUser();

        $deviceToken = $request->get("deviceToken");

        if($deviceToken == null) {
            $deviceToken = "";
        }

        $user->setUsername($email);
        $user->setEmail($email);
        $user->setPlainPassword($password);
        $user->setEnabled(true);
        $user->addRole('ROLE_USER');
        $user->setDeviceToken($deviceToken);

        $appVersion = $request->get("appVersion");
        if(!empty($appVersion)) {
            $user->setAppVersion($appVersion);
        }

        $osName = $request->get("osName");
        if(!empty($osName)) {
            $user->setOsName($osName);
        }

        $osVersion = $request->get("osVersion");
        if(!empty($osVersion)) {
            $user->setOsVersion($osVersion);
        }

        $deviceModel = $request->get("deviceModel");
        if(!empty($deviceModel)) {
            $user->setDeviceModel($deviceModel);
        }

        $country = $request->get("country");
        if(!empty($country)) {
            $user->setCountry($country);
        }

        $timeZone = $request->get("timeZone");
        if(!empty($timeZone)) {
            $user->setTimeZone($timeZone);
        }

        $userManager->updateCanonicalFields($user);
        $userManager->updatePassword($user);

        $em = $this->getDoctrine()->getManager();
        $em->persist($user);

        $em->flush();

        return $user;
    }

    private function updateUser(User $user, Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $userManager = $this->getUserManager();

        $password = $request->get('password');
        if($password != null) {
            $user->setPlainPassword($password);
            $userManager->updateCanonicalFields($user);
            $userManager->updatePassword($user);
        }

        $receivePushsFrom = $request->get('receivePushsFrom');
        if($receivePushsFrom != null) {
            $user->setReceivePushsFrom(new \DateTime($receivePushsFrom));
        }

        $receivePushsTo = $request->get('receivePushsTo');
        if($receivePushsTo != null) {
            $user->setReceivePushsTo(new \DateTime($receivePushsTo));
        }

        $em->persist($user);
        $em->flush();

        return $user;
    }

    private function updateUserOnLogin(User $user, Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $em->persist($user);

        $deviceToken = $request->get("deviceToken");
        if(!empty($deviceToken)) {
            $user->setDeviceToken($deviceToken);
        }

        $appVersion = $request->get("appVersion");
        if(!empty($appVersion)) {
            $user->setAppVersion($appVersion);
        }

        $osName = $request->get("osName");
        if(!empty($osName)) {
            $user->setOsName($osName);
        }

        $osVersion = $request->get("osVersion");
        if(!empty($osVersion)) {
            $user->setOsVersion($osVersion);
        }

        $deviceModel = $request->get("deviceModel");
        if(!empty($deviceModel)) {
            $user->setDeviceModel($deviceModel);
        }

        $country = $request->get("country");
        if(!empty($country)) {
            $user->setCountry($country);
        }

        $timeZone = $request->get("timeZone");
        if(!empty($timeZone)) {
            $user->setTimeZone($timeZone);
        }

        $em->flush();

        return $user;
    }

    private function createSerializedJsonResponse($object, $serializationList = null)
    {
        $serializer = $this->getSerializerService();
        if($serializationList) {
            $data = $serializer->serialize($object, 'json', $this->getSerializationContext($serializationList));
        } else {
            $data = $serializer->serialize($object, 'json');
        }

        $response = new Response($data, 200);
        $response->headers->set('Content-Type', 'application/json');

        return $response;
    }

    /**
     * Get new user
     *
     * @return \FOS\UserBundle\Doctrine\UserManager
     */
    private function getUserManager()
    {
        return $this->get('fos_user.user_manager');
    }

    /**
     * Get JMS Serializer
     *
     * @return \JMS\Serializer\Serializer
     */
    private function getSerializerService()
    {
        return $this->get('jms_serializer');
    }

    /**
     * Get serialization context
     *
     * @param $groups
     * @return \JMS\Serializer\SerializationContext
     */
    private function getSerializationContext($groups)
    {
        $context = SerializationContext::create();
        $context->setGroups($groups);
        return $context;
    }
}

src-Company-Bundle-BackendBundle-Resources-config-routing.yml

#
## User
#

company_backend_user_create:
    pattern:  registration
    defaults: { _controller: CompanyBackendBundle:User:create }
    methods:  [POST]

company_backend_user_update:
    pattern:  /v/1/user
    defaults: { _controller: CompanyBackendBundle:User:update }
    methods:  [PUT]

company_backend_user_login:
    pattern:  /v/1/user/login
    defaults: { _controller: CompanyBackendBundle:User:login }
    methods:  [PUT]