Completed
Push — feature/remote-vetting-check-l... ( d434a7 )
by
unknown
01:53
created

RemoteVettingContext::setState()   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 4

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
dl 0
loc 4
c 0
b 0
f 0
rs 10
cc 1
nc 1
nop 1
1
<?php
2
/**
3
 * Copyright 2010 SURFnet B.V.
4
 *
5
 * Licensed under the Apache License, Version 2.0 (the "License");
6
 * you may not use this file except in compliance with the License.
7
 * You may obtain a copy of the License at
8
 *
9
 *     http://www.apache.org/licenses/LICENSE-2.0
10
 *
11
 * Unless required by applicable law or agreed to in writing, software
12
 * distributed under the License is distributed on an "AS IS" BASIS,
13
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 * See the License for the specific language governing permissions and
15
 * limitations under the License.
16
 */
17
18
namespace Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting;
19
20
use Surfnet\StepupSelfService\SelfServiceBundle\Exception\InvalidRemoteVettingContextException;
21
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\Dto\AttributeListDto;
22
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\Value\ProcessId;
23
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\Dto\RemoteVettingProcessDto;
24
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\Dto\RemoteVettingTokenDto;
25
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\State\RemoteVettingState;
26
use Surfnet\StepupSelfService\SelfServiceBundle\Service\RemoteVetting\State\RemoteVettingStateInitialised;
27
use Symfony\Component\HttpFoundation\Session\SessionInterface;
28
29
class RemoteVettingContext
30
{
31
    const SESSION_KEY = 'remote-vetting-process';
32
33
    /**
34
     * @var RemoteVettingState
35
     */
36
    private $state;
37
    /**
38
     * @var SessionInterface
39
     */
40
    private $session;
41
42
    /**
43
     * @param SessionInterface $session
44
     */
45
    public function __construct(SessionInterface $session)
46
    {
47
        $this->session = $session;
48
        $this->state = new RemoteVettingStateInitialised();
49
    }
50
51
    /**
52
     * Do not use this method directly, this method is used to control state in the RemoteVettingState implementations.
53
     * This is done in order to comply with the state machine design pattern.
54
     *
55
     * @param RemoteVettingState $newState
56
     */
57
    public function setState(RemoteVettingState $newState)
58
    {
59
        $this->state = $newState;
60
    }
61
62
    /**
63
     * @param string $identityProviderName
64
     * @param RemoteVettingTokenDto $token
65
     */
66
    public function initialize($identityProviderName, RemoteVettingTokenDto $token)
67
    {
68
        $process = $this->state->handleInitialise($this, $identityProviderName, $token);
69
        $this->saveProcess($process);
70
    }
71
72
    /**
73
     * @param ProcessId $processId
74
     */
75
    public function validating(ProcessId $processId)
76
    {
77
        $process = $this->loadProcess();
78
        $process = $this->state->handleValidating($this, $process, $processId);
79
        $this->saveProcess($process);
80
    }
81
82
    /**
83
     * @param ProcessId $processId
84
     * @param AttributeListDto $xexternalAttributes
85
     */
86
    public function validated(ProcessId $processId, AttributeListDto $xexternalAttributes)
87
    {
88
        $process = $this->loadProcess();
89
        $process = $this->state->handleValidated($this, $process, $processId, $xexternalAttributes);
90
        $this->saveProcess($process);
91
    }
92
93
    /**
94
     * @param ProcessId $processId
95
     * @return RemoteVettingProcessDto
96
     */
97
    public function done(ProcessId $processId)
98
    {
99
        $process = $this->loadProcess();
100
        $token = $this->state->handleDone($this, $process, $processId);
0 ignored issues
show
Unused Code introduced by
The call to RemoteVettingState::handleDone() has too many arguments starting with $processId.

This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue.

If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress.

In this case you can add the @ignore PhpDoc annotation to the duplicate definition and it will be ignored.

Loading history...
101
        $this->saveProcess($process);
102
        return $token;
103
    }
104
105
    /**
106
     * @return RemoteVettingTokenDto
107
     */
108
    public function getValidatedToken()
109
    {
110
        $process = $this->loadProcess();
111
        return $this->state->getValidatedToken($process);
112
    }
113
114
    /**
115
     * @return AttributeListDto
116
     */
117
    public function getAttributes()
118
    {
119
        $process = $this->loadProcess();
120
        return $this->state->getAttributes($process);
121
    }
122
123
    /**
124
     * @return string
125
     */
126
    public function getIdentityProviderSlug()
127
    {
128
        $process = $this->loadProcess();
129
        return $process->getIdentityProviderName();
130
    }
131
132
    /**
133
     * @return string
134
     */
135
    public function getTokenId()
136
    {
137
        $process = $this->loadProcess();
138
        return $process->getToken()->getSecondFactorId();
139
    }
140
141
    /**
142
     * @return RemoteVettingProcessDto
143
     */
144
    private function loadProcess()
145
    {
146
        // get active process
147
        $serialized = $this->session->get(self::SESSION_KEY, null);
148
        if ($serialized == null) {
149
            throw new InvalidRemoteVettingContextException('No remote vetting process found');
150
        }
151
152
        $process = RemoteVettingProcessDto::deserialize($serialized);
153
154
        // update state from session
155
        $this->state = $process->getState();
156
157
        return $process;
158
    }
159
160
    /**
161
     * @param RemoteVettingProcessDto $process
162
     * @return void
163
     */
164
    private function saveProcess(RemoteVettingProcessDto $process)
165
    {
166
        // save state in session
167
        $process = RemoteVettingProcessDto::updateState($process, $this->state);
168
        $this->session->set(self::SESSION_KEY, $process->serialize());
169
    }
170
}
171