CRUD - jeden serwis czy każda akcja oddzielnie?

Question

Witam,

teraz mam jeden serwis UserService w którym mam metody odpowiadające za edycje, dodanie, usuwanie i pobieranie użytkownika, i tutaj jest moje pytanie: powinienem stworzyć dla każdej akcji oddzielny serwis? np UserCreate, UserEdit itp. czy zostawić to w jednym serwisie?

Comments

dziwi mnie to, że masz to w serwisie, a nie w modelu.

Po co serwis do zwykłego cruda, takie akcje powinny być raczej w modelu.

---

Ten serwis to wgl brzmi trochę jak fat controller dla mnie.

---

dziwi mnie to, że masz to w serwisie, a nie w modelu.

 Active record? To było dobre za czasów Symfony 1 i Propela.

---

@Ehlert który sposób polecasz?

---

Po pierwsze jeżeli korzystamy z jakiegoś frameworka to proszę o tym pisać w pytaniu, bo pytanie jest zadane bardzo ogólnikowo.

A skoro jest napisane ogólnikowo to przyjąłem zasadę: pisz kod jak najprościej i nie wrzucaj kilku warstw abstrakcji tylko po to, aby użyć jakiegoś patternu na siłę...

Zatem jeżeli korzystasz z frameworka to posługuj się patternami wg frameworka, a to, czy użyć kilka serwisów czy może jeden... to odpowiedź jak zawsze taka sama... To zależy.

---

Ale zaproponowałeś wrzucenie CRUDa do modelu. CRUD w modelu to pattern  który nazywa się Active Record. Tak, więc propozycja wzorca była z Twojej strony.

Ja byłem za serwisem, na dobrą sprawą jakąś klasą zarządzającą istnieniem obiektu. To nie jest żaden pattern, chyba żeby się uprzeć to fabryka, ale fabryka usuwająca to raczej nie fabryka. 

---

Tak po prawdzie wg podstawowego dzielenia aplikacji wg MVC takie rzeczy faktycznie lądowałyby w modelu (no bo ani to kontroler, ani widok).

---

Spoko.

Może za dużo ostatnio miałem przyjemności słuchać o przeroście formy nad treścią w aplikacjach, gdzie na siłę wrzucano patterny / dodatkowe warstwy abstrakcji itp... tylko po to aby ich użyć, a strasznie zaciemniały ogólne działanie kodu.

A de facto aplikacja była mała, gdzie logoki biznesowej mało, gdzie nie ma sensu się bawić we wszelkie patterny, bo po prostu utrudniają.

---

@Comandeer dlatego MVC odchodzi do lamusa 

---

@Ehlert - ale dlaczego MVC do lamusa...

Nie każdy pisze aplikacje, gdzie musisz mieć tryliard kodu i logiki... W czym jest zły MVC? 

Nie chcę tu nikogo atakować, tylko chyba we wszyskich tych patternach, czy je stosować, czy nie, czy może inne... To zależy - przynajmniej tak mi się wydaje.

---

@ViruS, spoko. Ja z kolei narobiłem się w syfiastych projektach gdzie nieliniowa logika była dosłownie upchana wszędzie, a każde miejsce wieńczyło 

$model->save();

Stąd też nienawiść do tego typu rozwiązań.

---

No tak, należy też pamiętać, że nazwanie wzorca, że jest kiepski tylko dlatego, bo inni używają go źle...

No, ale rozumiem Cię, bo użeram się codziennie z... brakiem jakichkolwiek patternów :P

---

Co do mojej niechęci do mvc... Może ona wynikać z tego iż wszystkie fw architektonicznie bazujące na tym wzorcu są przestarzałe... CI, Kohana, CodeIgniter, Zend, Symfony 1. O ile miałem okazję w nich pisać o tyle nie wyobrażam sobie implementacji w nich czegoś dużego.

Answer 1

IMO Twój serwis jest ok. Może przydałaby się bardziej intuicyjna nazwa i na pewno testy.

Comments

kod jak na razie wygląda tak:

<?php

declare(strict_types=1);

namespace App\Service;

use App\Entity\User;
use App\Repository\UserRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;

class UserService
{
    /** @var EntityManagerInterface  */
    private $entityManager;

    /** @var UserRepository */
    private $userRepository;

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

    /** @var AccountService */
    private $accountService;

    /**
     * @param EntityManagerInterface $entityManager
     * @param UserRepository $userRepository
     * @param UserPasswordEncoderInterface $encoder
     * @param AccountService $accountService
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        UserRepository $userRepository,
        UserPasswordEncoderInterface $encoder,
        AccountService $accountService
    ) {
        $this->entityManager = $entityManager;
        $this->userRepository = $userRepository;
        $this->passwordEncoder = $encoder;
        $this->accountService = $accountService;
    }

    /**
     * @param User $user
     * @return string
     */
    public function createUser(User $user): string
    {
        $account = $this->accountService->createAccount();

        $user->setAccount($account);
        $user->setPassword(
            $this->passwordEncoder->encodePassword($user, $user->getPlainPassword())
        );

        $this->entityManager->persist($account);
        $this->entityManager->persist($user);
        $this->entityManager->flush();

        return $user->getUsername();
    }

    /**
     * @param string $username
     * @return User|false
     *
     * TODO Add return type declaration
     */
    public function getUserByUsername(string $username)
    {
        $user = $this->userRepository->findOneBy([
            'username' => $username,
        ]);

        return $user instanceof User ? $user : false;
    }
}

<?php

declare(strict_types=1);

namespace App\Service;

use App\Entity\Accounts;
use App\Repository\AccountsRepository;
use Doctrine\ORM\EntityManagerInterface;

class AccountService
{
    /** @var EntityManagerInterface */
    private $entityManager;

    /** @var AccountsRepository */
    private $accountsRepository;

    /** @var UserService */
    private $userService;

    /**
     * @param EntityManagerInterface $entityManager
     * @param AccountsRepository $accountsRepository
     * @param UserService $userService
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        AccountsRepository $accountsRepository,
        UserService $userService
    ) {
        $this->entityManager = $entityManager;
        $this->accountsRepository = $accountsRepository;
        $this->userService = $userService;
    }

    /**
     * @return Accounts
     */
    public function createAccount(): Accounts
    {
        $account = new Accounts();
        $account->setFirstName("-");

        return $account;
    }

    /**
     * @param Accounts $data
     * @param string $username
     *
     * @return Accounts|boolean
     *
     * TODO Add return type declaration
     */
    public function updateAccount(Accounts $data, string $username)
    {
        $user = $this->userService->getUserByUsername($username);

        if ($user) {
            $account = $this->accountsRepository->find($user->getAccount()->getId());
        } else {
            return false;
        }

        if (!$account instanceof Accounts) {
            return false;
        }

        $account->setFirstName($data->getFirstName());

        $this->entityManager->flush();

        return $account;
    }
}

tylko muszę go troche zrefaktoryzować bo wyskakuje błąd circular reference