AbstractMapper.php 5.12 KB
Newer Older
1
<?php
2

3
4
namespace UnicaenApp\Mapper\Ldap;

5
6
use Zend\Ldap\Dn;
use Zend\Ldap\Filter\AbstractFilter;
7
use Zend\Ldap\Ldap;
8
use UnicaenApp\Exception\RuntimeException;
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Classe mère des services d'accès à l'annuaire LDAP.
 *
 * @author Bertrand GAUTHIER <bertrand.gauthier@unicaen.fr>
 */
abstract class AbstractMapper
{
    /**
     * @var Ldap
     */
    protected $ldap;

22
23
24
25
26
    /**
     * @var array
     */
    protected $config;

27
28
29
    /**
     * Constructeur.
     *
30
31
     * @param Ldap  $ldap Objet d'accès à l'annuaire LDAP
     * @param array $config
32
     */
33
    public function __construct(Ldap $ldap = null, array $config = [])
34
    {
35
        $this->setLdap($ldap);
36
        $this->setConfig($config);
37
    }
38

39
40
41
    /**
     * Retourne la liste des attributs LDAP remontés dans les résultats de recherches.
     * NB: l'attribut 'dn' est forcément inclus.
42
     *
43
44
45
     * @return array e.g. array("mail", "sn", "cn")
     */
    abstract public function getAttributes();
46
47
48
49
50
51
52
53
54
55

    /**
     * Retourne l'objet d'accès à l'annuaire LDAP.
     *
     * @return Ldap
     */
    public function getLdap()
    {
        return $this->ldap;
    }
56

57
58
59
60
61
62
    /**
     * Spécifie l'objet d'accès à l'annuaire LDAP.
     *
     * @param Ldap $ldap
     * @return AbstractMapper
     */
63
    public function setLdap(Ldap $ldap = null)
64
65
    {
        $this->ldap = $ldap;
66

67
68
        return $this;
    }
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

    /**
     * @return array
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * @param array $config
     * @return AbstractMapper
     */
    public function setConfig($config)
    {
        $this->config = $config;

        return $this;
    }

    /**
     * @param string $name
     * @param string $category
     * @return string
     */
    public function configParam($category, $name)
    {
        if (empty($this->config[$category][$name])) {
            throw new RuntimeException("Le tableau de config doit fournir une valeur valide pour le paramètre ['$category']['$name']");
        }

        return $this->config[$category][$name];
    }

103
104
105
    /**
     * Cherche une entrée dans l'annuaire LDAP selon un filtre puis parcourt récursivement le résultat trouvé
     * pour remplacer tout array qui ne contient qu'une seule valeur par cette valeur.
106
107
108
109
110
111
     *
     * @param string|AbstractFilter|array $filter
     * @param string                      $baseDn
     * @param array                       $attributes
     * @param string|null                 $sort
     * @param int                         $scope
112
113
     * @return array
     */
114
    public function searchSimplifiedEntry($filter, $baseDn = null, array $attributes = [], $sort = null, $scope = Ldap::SEARCH_SCOPE_SUB)
115
    {
116
        if (!$attributes) {
117
            $attributes = $this->getAttributes() ?: ['*'];
118
        }
119
        $entries = @$this->getLdap()->searchEntries($filter, $baseDn, $scope, $attributes, $sort);
120
        if (count($entries) > 1) {
121
            throw new RuntimeException("Plus d'une entrée trouvée avec ce filtre: " . $filter);
122
123
124
125
126
        }
        if (!$entries) {
            return null;
        }
        $entry = $entries[0];
127

128
129
130
131
132
133
134
        return self::simplifiedEntry($entry);
    }

    /**
     * Cherche des entrées dans l'annuaire LDAP selon un filtre puis parcourt récursivement les entrées trouvées
     * pour remplacer tout array qui ne contient qu'une seule valeur par cette valeur.
     *
135
136
137
138
139
     * @param  string|AbstractFilter|array $filter
     * @param  string|Dn|null              $basedn
     * @param  array                       $attributes
     * @param  string|null                 $sort
     * @param  integer                     $scope
140
141
     * @return array
     */
142
    public function searchSimplifiedEntries($filter, $basedn = null, array $attributes = [], $sort = null, $scope = Ldap::SEARCH_SCOPE_SUB)
143
    {
144
        if (!$attributes) {
145
            $attributes = $this->getAttributes() ?: ['*'];
146
        }
147
        $entries = $this->getLdap()->searchEntries($filter, $basedn, $scope, $attributes, $sort);
148
149
150
        foreach ($entries as $i => $entry) {
            $entries[$i] = self::simplifiedEntry($entry);
        }
151

152
153
154
155
156
157
        return $entries;
    }

    /**
     * Parcours récursivement le tableau spécifié pour remplacer tout array qui ne contient
     * qu'une seule valeur par cette valeur.
158
     *
159
     * @param array $entry
160
161
     * @param array $returnAttribs
     * @param array $omitAttribs
162
163
     * @return array Le tableau "simplifié"
     */
164
    static public function simplifiedEntry(array $entry, array $returnAttribs = [], array $omitAttribs = [])
165
    {
166
167
        $return = [];

168
169
170
171
172
173
174
        foreach ($entry as $attr => $value) {
            if (($returnAttribs && !in_array($attr, $returnAttribs)) || ($omitAttribs && in_array($attr, $omitAttribs))) {
                continue;
            }
            if (is_array($value)) {
                if (count($value) > 1) {
                    $return[$attr] = self::simplifiedEntry($value);
175
176
                } else {
                    $return[$attr] = count($value) === 1 ? $value[0] : [];
177
                }
178
            } else {
179
180
181
182
183
184
185
                $return[$attr] = $value;
            }
        }

        return $return;
    }
}