zend-blog-3-backend

1
<?php
2

3
namespace App\Service;
4

5
use App\DTO\ExternalUserDTO;
6
use App\Entity\User;
7
use App\Entity\UserExtraInfo;
8
use App\Exception\ShortPasswordException;
9
use Doctrine\ORM\EntityManager;
10
use Doctrine\ORM\EntityManagerInterface;
11
use Exception;
12
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
13

14
class UserManager
15
{
16
    /**
17
     * @var EntityManager
18
     */
19
    private $em;
20

21
    private UserPasswordHasherInterface $passwordHasher;
22

23
    /**
24
     * @var Tracking
25
     */
26
    private $tracking;
27

28
    public function __construct(
29
        EntityManagerInterface $em,
30
        UserPasswordHasherInterface $passwordHasher,
31
        Tracking $tracking
32
    ) {
33
        $this->em = $em;
34
        $this->passwordHasher = $passwordHasher;
35
        $this->tracking = $tracking;
36
    }
37

38
    public function findByExternalDTO(ExternalUserDTO $data): array
39
    {
40
        $infoRepository = $this->em->getRepository(UserExtraInfo::class);
41
        $userInfo = $infoRepository->findOneBy([
42
            'externalId' => $data->id,
43
            'dataProvider' => $data->dataProvider,
44
        ]);
45

46
        if ($userInfo) {
47
            return [$userInfo->getUser(), true];
48
        }
49

50
        if (!empty($data->email)) {
51
            $userRepository = $this->em->getRepository(User::class);
52
            $user = $userRepository->findOneBy(['email' => $data->email]);
53
            if ($user) {
54
                return [$user, false];
55
            }
56
        }
57

58
        return [null, false];
59
    }
60

61
    public function createFromExternalDTO(ExternalUserDTO $data): User
62
    {
63
        $generatedUsername = 'ext-' . str_pad(mt_rand(0, 9999999), 7, '0', STR_PAD_LEFT);
64
        $userRepository = $this->em->getRepository(User::class);
65

66
        $username = $data->username;
67
        $email = $data->email;
68

69
        if (empty($username)) {
70
            $username = $generatedUsername;
71
        } else {
72
            $temporaryUser = $userRepository->findOneByUsername($username);
73
            if ($temporaryUser) {
74
                $username = $generatedUsername;
75
            }
76
        }
77

78
        if (empty($email)) {
79
            $email = $generatedUsername . '@xelbot.fake';
80
        }
81

82
        $user = $this->createUser($username, $email);
83

84
        if (!empty($data->displayName)) {
85
            $user->setDisplayName($data->displayName);
86
        }
87

88
        if (!empty($data->gender) && $data->gender === 'female') {
89
            $user->setGender(User::FEMALE);
90
        }
91

92
        return $user;
93
    }
94

95
    /**
96
     * @param string $username
97
     * @param string $email
98
     * @param string|null $password
99
     *
100
     * @return User
101
     */
102
    public function createUser(string $username, string $email, string $password = null): User
103
    {
104
        if (is_null($password)) {
105
            try {
106
                $password = base64_encode(random_bytes(32));
107
            } catch (Exception $exception) {
108
                $password = hash('sha256', uniqid(mt_rand(), true));
109
            }
110
        }
111

112
        $user = new User();
113
        $user
114
            ->setUsername($username)
115
            ->setEmail($email)
116
            ->setPassword($this->passwordHasher->hashPassword($user, $password))
117
        ;
118

119
        return $user;
120
    }
121

122
    /**
123
     * @param User $user
124
     * @param string $password
125
     *
126
     * @throws ShortPasswordException
127
     * @throws \Doctrine\ORM\Exception\ORMException
128
     */
129
    public function updatePassword(User $user, string $password): void
130
    {
131
        if (strlen($password) <= 4) {
132
            throw new ShortPasswordException('Password too short');
133
        }
134

135
        $user->setRandomSalt();
136
        $user->setRandomWsseKey();
137

138
        $user->setPassword($this->passwordHasher->hashPassword($user, $password));
139

140
        $this->em->persist($user);
141
        $this->em->flush();
142
    }
143

144
    public function saveUserExtraInfo(ExternalUserDTO $data, User $user, ?string $ip, ?string $userAgent): UserExtraInfo
145
    {
146
        $agent = $userAgent ? $this->tracking->getTrackingAgent($userAgent) : null;
147

148
        $userInfo = new UserExtraInfo();
149
        $userInfo
150
            ->setUser($user)
151
            ->setExternalId($data->id)
152
            ->setDataProvider($data->dataProvider)
153
            ->setRawData($data->rawData)
154
            ->setIpAddress($ip)
155
            ->setTrackingAgent($agent)
156
            ->setUsername($data->username)
157
            ->setFirstName($data->firstName)
158
            ->setLastName($data->lastName)
159
            ->setDisplayName($data->displayName)
160
            ->setEmail($data->email)
161
            ->setAvatar($data->avatar)
162
        ;
163

164
        if ($data->gender === 'female') {
165
            $userInfo->setGender(UserExtraInfo::FEMALE);
166
        } elseif ($data->gender === 'male') {
167
            $userInfo->setGender(UserExtraInfo::MALE);
168
        }
169

170
        $this->em->persist($userInfo);
171
        $this->em->flush();
172

173
        return $userInfo;
174
    }
175
}
176