Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
68.06% covered (warning)
68.06%
98 / 144
73.68% covered (warning)
73.68%
14 / 19
CRAP
0.00% covered (danger)
0.00%
0 / 1
Useraccount
68.06% covered (warning)
68.06%
98 / 144
73.68% covered (warning)
73.68%
14 / 19
103.27
0.00% covered (danger)
0.00%
0 / 1
 readIsUserExisting
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
3
 readEntity
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
1
 readResolvedReferences
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
3
 readList
100.00% covered (success)
100.00%
9 / 9
100.00% covered (success)
100.00%
1 / 1
3
 readListStatement
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
6
 readAssignedDepartmentList
100.00% covered (success)
100.00%
12 / 12
100.00% covered (success)
100.00%
1 / 1
4
 readEntityByAuthKey
100.00% covered (success)
100.00%
7 / 7
100.00% covered (success)
100.00%
1 / 1
2
 readEntityByUserId
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
2
 readCollectionByDepartmentId
100.00% covered (success)
100.00%
10 / 10
100.00% covered (success)
100.00%
1 / 1
3
 writeEntity
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
2
 writeUpdatedEntity
100.00% covered (success)
100.00%
7 / 7
100.00% covered (success)
100.00%
1 / 1
1
 deleteEntity
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
1
 updateAssignedDepartments
100.00% covered (success)
100.00%
12 / 12
100.00% covered (success)
100.00%
1 / 1
3
 readEntityIdByLoginName
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
1
 deleteAssignedDepartments
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
1
 readSearch
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
12
 readSearchByDepartmentId
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
12
 readListRole
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
6
 readListByRoleAndDepartment
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
12
1<?php
2
3namespace BO\Zmsdb;
4
5use BO\Zmsentities\Useraccount as Entity;
6use BO\Zmsentities\Collection\UseraccountList as Collection;
7
8/**
9 * @SuppressWarnings(Public)
10 *
11 */
12class Useraccount extends Base
13{
14    public function readIsUserExisting($loginName, $password = false)
15    {
16        $query = new Query\Useraccount(Query\Base::SELECT);
17        $query->addEntityMapping()
18            ->setResolveLevel(0)
19            ->addConditionLoginName($loginName);
20        if ($password) {
21            $query->addConditionPassword($password);
22        }
23        $useraccount = $this->fetchOne($query, new Entity());
24        return ($useraccount->hasId()) ? true : false;
25    }
26
27    public function readEntity($loginname, $resolveReferences = 1)
28    {
29        $query = new Query\Useraccount(Query\Base::SELECT);
30        $query->addEntityMapping()
31            ->addResolvedReferences($resolveReferences)
32            ->addConditionLoginName($loginname);
33        $useraccount = $this->fetchOne($query, new Entity());
34        return $this->readResolvedReferences($useraccount, $resolveReferences);
35    }
36
37    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $useraccount, $resolveReferences)
38    {
39        if (0 < $resolveReferences && $useraccount->toProperty()->id->get()) {
40            // TODO subtract -1 from resolveReference, but check calling functions!
41            $useraccount->departments = $this->readAssignedDepartmentList($useraccount, $resolveReferences);
42        }
43        return $useraccount;
44    }
45
46    /**
47     * read list of useraccounts
48     *
49     * @param
50     *            resolveReferences
51     *
52     * @return Resource Collection
53     */
54    public function readList($resolveReferences = 0)
55    {
56        $collection = new Collection();
57        $query = new Query\Useraccount(Query\Base::SELECT);
58        $query->addResolvedReferences($resolveReferences)
59            ->addEntityMapping();
60        $result = $this->fetchList($query, new Entity());
61        if (count($result)) {
62            foreach ($result as $entity) {
63                $collection->addEntity($this->readResolvedReferences($entity, $resolveReferences));
64            }
65        }
66        return $collection;
67    }
68
69    protected function readListStatement($statement, $resolveReferences)
70    {
71        $query = new Query\Useraccount(Query\Base::SELECT);
72        $collection = new Collection();
73        while ($userAccountData = $statement->fetch(\PDO::FETCH_ASSOC)) {
74            $entity = new Entity($query->postProcessJoins($userAccountData));
75            $entity = $this->readResolvedReferences($entity, $resolveReferences);
76            $collection->addEntity($entity);
77        }
78        return $collection;
79    }
80
81    /**
82     * read list assigned departments
83     *
84     * @param
85     *            resolveReferences
86     *
87     * @return Resource Collection
88     */
89    public function readAssignedDepartmentList($useraccount, $resolveReferences = 0)
90    {
91        if ($useraccount->isSuperUser()) {
92            $query = Query\Useraccount::QUERY_READ_SUPERUSER_DEPARTMENTS;
93            $departmentIds = $this->getReader()->fetchAll($query);
94        } else {
95            $query = Query\Useraccount::QUERY_READ_ASSIGNED_DEPARTMENTS;
96            $departmentIds = $this->getReader()->fetchAll($query, ['useraccountName' => $useraccount->id]);
97        }
98        $departmentList = new \BO\Zmsentities\Collection\DepartmentList();
99        foreach ($departmentIds as $item) {
100            $department = (new \BO\Zmsdb\Department())->readEntity($item['id'], $resolveReferences);
101            if ($department instanceof \BO\Zmsentities\Department) {
102                $department->name = $item['organisation__name'] . ' -> ' . $department->name;
103                $departmentList->addEntity($department);
104            }
105        }
106        return $departmentList;
107    }
108
109    public function readEntityByAuthKey($xAuthKey, $resolveReferences = 0)
110    {
111        $hashedAuthKey = hash('sha256', $xAuthKey);
112        $query = new Query\Useraccount(Query\Base::SELECT);
113        $query->addEntityMapping()
114            ->addResolvedReferences($resolveReferences)
115            ->addConditionXauthKey($hashedAuthKey);
116        $entity = ($hashedAuthKey) ? $this->fetchOne($query, new Entity()) : new Entity();
117        return $this->readResolvedReferences($entity, $resolveReferences);
118    }
119
120    public function readEntityByUserId($userId, $resolveReferences = 0)
121    {
122        $query = new Query\Useraccount(Query\Base::SELECT);
123        $query->addEntityMapping()
124            ->addResolvedReferences($resolveReferences)
125            ->addConditionUserId($userId);
126        $entity = ($userId) ? $this->fetchOne($query, new Entity()) : new Entity();
127        return $this->readResolvedReferences($entity, $resolveReferences);
128    }
129
130    public function readCollectionByDepartmentId($departmentId, $resolveReferences = 0)
131    {
132        $collection = new Collection();
133        $query = new Query\Useraccount(Query\Base::SELECT);
134        $query->addResolvedReferences($resolveReferences)
135            ->addConditionDepartmentId($departmentId)
136            ->addEntityMapping();
137        $result = $this->fetchList($query, new Entity());
138        if (count($result)) {
139            foreach ($result as $entity) {
140                $collection->addEntity($this->readResolvedReferences($entity, $resolveReferences));
141            }
142        }
143        return $collection;
144    }
145
146    /**
147     * write an useraccount
148     *
149     * @param
150     *            entity
151     *
152     * @return Entity
153     */
154    public function writeEntity(\BO\Zmsentities\Useraccount $entity, $resolveReferences = 0)
155    {
156        if ($this->readIsUserExisting($entity->id)) {
157            throw new Exception\Useraccount\DuplicateEntry();
158        }
159        $query = new Query\Useraccount(Query\Base::INSERT);
160        $values = $query->reverseEntityMapping($entity);
161        $query->addValues($values);
162        $this->writeItem($query);
163        $this->updateAssignedDepartments($entity);
164        return $this->readEntity($entity->getId(), $resolveReferences);
165    }
166
167    /**
168     * update a useraccount
169     *
170     * @param
171     *            useraccountId
172     *
173     * @return Entity
174     */
175    public function writeUpdatedEntity($loginName, \BO\Zmsentities\Useraccount $entity, $resolveReferences = 0)
176    {
177        $query = new Query\Useraccount(Query\Base::UPDATE);
178        $query->addConditionLoginName($loginName);
179        $values = $query->reverseEntityMapping($entity);
180        $query->addValues($values);
181        $this->writeItem($query);
182        $this->updateAssignedDepartments($entity);
183        return $this->readEntity($entity->getId(), $resolveReferences);
184    }
185
186    /**
187     * remove an user
188     *
189     * @param
190     *            itemId
191     *
192     * @return Resource Status
193     */
194    public function deleteEntity($loginName)
195    {
196        $query = new Query\Useraccount(Query\Base::DELETE);
197        $query->addConditionLoginName($loginName);
198        $this->deleteAssignedDepartments($loginName);
199        return $this->deleteItem($query);
200    }
201
202    protected function updateAssignedDepartments($entity)
203    {
204        $loginName = $entity->id;
205        if (!$entity->isSuperUser()) {
206            $this->deleteAssignedDepartments($loginName);
207            $userId = $this->readEntityIdByLoginName($loginName);
208            foreach ($entity->departments as $department) {
209                $this->perform(
210                    Query\Useraccount::QUERY_WRITE_ASSIGNED_DEPARTMENTS,
211                    array(
212                        $userId,
213                        $department['id']
214                    )
215                );
216            }
217        }
218    }
219
220    protected function readEntityIdByLoginName($loginName)
221    {
222        $query = Query\Useraccount::QUERY_READ_ID_BY_USERNAME;
223        $result = $this->getReader()->fetchOne($query, [$loginName]);
224        return $result['id'];
225    }
226
227    protected function deleteAssignedDepartments($loginName)
228    {
229        $query = Query\Useraccount::QUERY_DELETE_ASSIGNED_DEPARTMENTS;
230        $userId = $this->readEntityIdByLoginName($loginName);
231        return $this->perform($query, [$userId]);
232    }
233
234    public function readSearch(array $parameter, $resolveReferences = 0)
235    {
236        $query = new Query\Useraccount(Query\Base::SELECT);
237        $query
238            ->addResolvedReferences($resolveReferences)
239            ->addEntityMapping();
240
241        if (isset($parameter['query'])) {
242            if (preg_match('#^\d+$#', $parameter['query'])) {
243                $query->addConditionUserId($parameter['query']);
244                $query->addConditionSearch($parameter['query'], true);
245            } else {
246                $query->addConditionSearch($parameter['query']);
247            }
248            unset($parameter['query']);
249        }
250
251        $statement = $this->fetchStatement($query);
252        return $this->readListStatement($statement, $resolveReferences);
253    }
254
255    public function readSearchByDepartmentId($departmentId, array $parameter, $resolveReferences = 0)
256    {
257        $query = new Query\Useraccount(Query\Base::SELECT);
258        $query->addResolvedReferences($resolveReferences)
259            ->addEntityMapping();
260
261        if (isset($parameter['query'])) {
262            if (preg_match('#^\d+$#', $parameter['query'])) {
263                $query->addConditionUserId($parameter['query']);
264                $query->addConditionDepartmentAndSearch($departmentId, $parameter['query'], true);
265            } else {
266                $query->addConditionDepartmentAndSearch($departmentId, $parameter['query']);
267            }
268            unset($parameter['query']);
269        } else {
270            $query->addConditionDepartmentId($departmentId);
271        }
272
273        $statement = $this->fetchStatement($query);
274        return $this->readListStatement($statement, $resolveReferences);
275    }
276
277    public function readListRole($roleLevel, $resolveReferences = 0)
278    {
279        $query = new Query\Useraccount(Query\Base::SELECT);
280        $query->addResolvedReferences($resolveReferences)
281            ->addEntityMapping();
282
283        if (isset($roleLevel)) {
284            $query->addConditionRoleLevel($roleLevel);
285        }
286
287        $statement = $this->fetchStatement($query);
288        return $this->readListStatement($statement, $resolveReferences);
289    }
290
291    public function readListByRoleAndDepartment($roleLevel, $departmentId, $resolveReferences = 0)
292    {
293        $query = new Query\Useraccount(Query\Base::SELECT);
294        $query->addResolvedReferences($resolveReferences)
295              ->addEntityMapping();
296
297        if (isset($roleLevel) && isset($departmentId)) {
298            $query->addConditionRoleLevel($roleLevel);
299            $query->addConditionDepartmentId($departmentId);
300        }
301
302        $statement = $this->fetchStatement($query);
303        return $this->readListStatement($statement, $resolveReferences);
304    }
305}