Completed
Pull Request — master (#5231)
by Morris
16:38
created
apps/user_ldap/lib/Mapping/UserMapping.php 1 patch
Indentation   +7 added lines, -7 removed lines patch added patch discarded remove patch
@@ -29,12 +29,12 @@
 block discarded – undo
29 29
 */
30 30
 class UserMapping extends AbstractMapping {
31 31
 
32
-	/**
33
-	 * returns the DB table name which holds the mappings
34
-	 * @return string
35
-	 */
36
-	protected function getTableName() {
37
-		return '*PREFIX*ldap_user_mapping';
38
-	}
32
+    /**
33
+     * returns the DB table name which holds the mappings
34
+     * @return string
35
+     */
36
+    protected function getTableName() {
37
+        return '*PREFIX*ldap_user_mapping';
38
+    }
39 39
 
40 40
 }
Please login to merge, or discard this patch.
apps/user_ldap/lib/Mapping/AbstractMapping.php 2 patches
Indentation   +200 added lines, -200 removed lines patch added patch discarded remove patch
@@ -29,252 +29,252 @@
 block discarded – undo
29 29
 * @package OCA\User_LDAP\Mapping
30 30
 */
31 31
 abstract class AbstractMapping {
32
-	/**
33
-	 * @var \OCP\IDBConnection $dbc
34
-	 */
35
-	protected $dbc;
32
+    /**
33
+     * @var \OCP\IDBConnection $dbc
34
+     */
35
+    protected $dbc;
36 36
 
37
-	/**
38
-	 * returns the DB table name which holds the mappings
39
-	 * @return string
40
-	 */
41
-	abstract protected function getTableName();
37
+    /**
38
+     * returns the DB table name which holds the mappings
39
+     * @return string
40
+     */
41
+    abstract protected function getTableName();
42 42
 
43
-	/**
44
-	 * @param \OCP\IDBConnection $dbc
45
-	 */
46
-	public function __construct(\OCP\IDBConnection $dbc) {
47
-		$this->dbc = $dbc;
48
-	}
43
+    /**
44
+     * @param \OCP\IDBConnection $dbc
45
+     */
46
+    public function __construct(\OCP\IDBConnection $dbc) {
47
+        $this->dbc = $dbc;
48
+    }
49 49
 
50
-	/**
51
-	 * checks whether a provided string represents an existing table col
52
-	 * @param string $col
53
-	 * @return bool
54
-	 */
55
-	public function isColNameValid($col) {
56
-		switch($col) {
57
-			case 'ldap_dn':
58
-			case 'owncloud_name':
59
-			case 'directory_uuid':
60
-				return true;
61
-			default:
62
-				return false;
63
-		}
64
-	}
50
+    /**
51
+     * checks whether a provided string represents an existing table col
52
+     * @param string $col
53
+     * @return bool
54
+     */
55
+    public function isColNameValid($col) {
56
+        switch($col) {
57
+            case 'ldap_dn':
58
+            case 'owncloud_name':
59
+            case 'directory_uuid':
60
+                return true;
61
+            default:
62
+                return false;
63
+        }
64
+    }
65 65
 
66
-	/**
67
-	 * Gets the value of one column based on a provided value of another column
68
-	 * @param string $fetchCol
69
-	 * @param string $compareCol
70
-	 * @param string $search
71
-	 * @throws \Exception
72
-	 * @return string|false
73
-	 */
74
-	protected function getXbyY($fetchCol, $compareCol, $search) {
75
-		if(!$this->isColNameValid($fetchCol)) {
76
-			//this is used internally only, but we don't want to risk
77
-			//having SQL injection at all.
78
-			throw new \Exception('Invalid Column Name');
79
-		}
80
-		$query = $this->dbc->prepare('
66
+    /**
67
+     * Gets the value of one column based on a provided value of another column
68
+     * @param string $fetchCol
69
+     * @param string $compareCol
70
+     * @param string $search
71
+     * @throws \Exception
72
+     * @return string|false
73
+     */
74
+    protected function getXbyY($fetchCol, $compareCol, $search) {
75
+        if(!$this->isColNameValid($fetchCol)) {
76
+            //this is used internally only, but we don't want to risk
77
+            //having SQL injection at all.
78
+            throw new \Exception('Invalid Column Name');
79
+        }
80
+        $query = $this->dbc->prepare('
81 81
 			SELECT `' . $fetchCol . '`
82 82
 			FROM `'. $this->getTableName() .'`
83 83
 			WHERE `' . $compareCol . '` = ?
84 84
 		');
85 85
 
86
-		$res = $query->execute(array($search));
87
-		if($res !== false) {
88
-			return $query->fetchColumn();
89
-		}
86
+        $res = $query->execute(array($search));
87
+        if($res !== false) {
88
+            return $query->fetchColumn();
89
+        }
90 90
 
91
-		return false;
92
-	}
91
+        return false;
92
+    }
93 93
 
94
-	/**
95
-	 * Performs a DELETE or UPDATE query to the database.
96
-	 * @param \Doctrine\DBAL\Driver\Statement $query
97
-	 * @param array $parameters
98
-	 * @return bool true if at least one row was modified, false otherwise
99
-	 */
100
-	protected function modify($query, $parameters) {
101
-		$result = $query->execute($parameters);
102
-		return ($result === true && $query->rowCount() > 0);
103
-	}
94
+    /**
95
+     * Performs a DELETE or UPDATE query to the database.
96
+     * @param \Doctrine\DBAL\Driver\Statement $query
97
+     * @param array $parameters
98
+     * @return bool true if at least one row was modified, false otherwise
99
+     */
100
+    protected function modify($query, $parameters) {
101
+        $result = $query->execute($parameters);
102
+        return ($result === true && $query->rowCount() > 0);
103
+    }
104 104
 
105
-	/**
106
-	 * Gets the LDAP DN based on the provided name.
107
-	 * Replaces Access::ocname2dn
108
-	 * @param string $name
109
-	 * @return string|false
110
-	 */
111
-	public function getDNByName($name) {
112
-		return $this->getXbyY('ldap_dn', 'owncloud_name', $name);
113
-	}
105
+    /**
106
+     * Gets the LDAP DN based on the provided name.
107
+     * Replaces Access::ocname2dn
108
+     * @param string $name
109
+     * @return string|false
110
+     */
111
+    public function getDNByName($name) {
112
+        return $this->getXbyY('ldap_dn', 'owncloud_name', $name);
113
+    }
114 114
 
115
-	/**
116
-	 * Updates the DN based on the given UUID
117
-	 * @param string $fdn
118
-	 * @param string $uuid
119
-	 * @return bool
120
-	 */
121
-	public function setDNbyUUID($fdn, $uuid) {
122
-		$query = $this->dbc->prepare('
115
+    /**
116
+     * Updates the DN based on the given UUID
117
+     * @param string $fdn
118
+     * @param string $uuid
119
+     * @return bool
120
+     */
121
+    public function setDNbyUUID($fdn, $uuid) {
122
+        $query = $this->dbc->prepare('
123 123
 			UPDATE `' . $this->getTableName() . '`
124 124
 			SET `ldap_dn` = ?
125 125
 			WHERE `directory_uuid` = ?
126 126
 		');
127 127
 
128
-		return $this->modify($query, array($fdn, $uuid));
129
-	}
128
+        return $this->modify($query, array($fdn, $uuid));
129
+    }
130 130
 
131
-	/**
132
-	 * Updates the UUID based on the given DN
133
-	 *
134
-	 * required by Migration/UUIDFix
135
-	 *
136
-	 * @param $uuid
137
-	 * @param $fdn
138
-	 * @return bool
139
-	 */
140
-	public function setUUIDbyDN($uuid, $fdn) {
141
-		$query = $this->dbc->prepare('
131
+    /**
132
+     * Updates the UUID based on the given DN
133
+     *
134
+     * required by Migration/UUIDFix
135
+     *
136
+     * @param $uuid
137
+     * @param $fdn
138
+     * @return bool
139
+     */
140
+    public function setUUIDbyDN($uuid, $fdn) {
141
+        $query = $this->dbc->prepare('
142 142
 			UPDATE `' . $this->getTableName() . '`
143 143
 			SET `directory_uuid` = ?
144 144
 			WHERE `ldap_dn` = ?
145 145
 		');
146 146
 
147
-		return $this->modify($query, [$uuid, $fdn]);
148
-	}
147
+        return $this->modify($query, [$uuid, $fdn]);
148
+    }
149 149
 
150
-	/**
151
-	 * Gets the name based on the provided LDAP DN.
152
-	 * @param string $fdn
153
-	 * @return string|false
154
-	 */
155
-	public function getNameByDN($fdn) {
156
-		return $this->getXbyY('owncloud_name', 'ldap_dn', $fdn);
157
-	}
150
+    /**
151
+     * Gets the name based on the provided LDAP DN.
152
+     * @param string $fdn
153
+     * @return string|false
154
+     */
155
+    public function getNameByDN($fdn) {
156
+        return $this->getXbyY('owncloud_name', 'ldap_dn', $fdn);
157
+    }
158 158
 
159
-	/**
160
-	 * Searches mapped names by the giving string in the name column
161
-	 * @param string $search
162
-	 * @param string $prefixMatch
163
-	 * @param string $postfixMatch
164
-	 * @return string[]
165
-	 */
166
-	public function getNamesBySearch($search, $prefixMatch = "", $postfixMatch = "") {
167
-		$query = $this->dbc->prepare('
159
+    /**
160
+     * Searches mapped names by the giving string in the name column
161
+     * @param string $search
162
+     * @param string $prefixMatch
163
+     * @param string $postfixMatch
164
+     * @return string[]
165
+     */
166
+    public function getNamesBySearch($search, $prefixMatch = "", $postfixMatch = "") {
167
+        $query = $this->dbc->prepare('
168 168
 			SELECT `owncloud_name`
169 169
 			FROM `'. $this->getTableName() .'`
170 170
 			WHERE `owncloud_name` LIKE ?
171 171
 		');
172 172
 
173
-		$res = $query->execute(array($prefixMatch.$this->dbc->escapeLikeParameter($search).$postfixMatch));
174
-		$names = array();
175
-		if($res !== false) {
176
-			while($row = $query->fetch()) {
177
-				$names[] = $row['owncloud_name'];
178
-			}
179
-		}
180
-		return $names;
181
-	}
173
+        $res = $query->execute(array($prefixMatch.$this->dbc->escapeLikeParameter($search).$postfixMatch));
174
+        $names = array();
175
+        if($res !== false) {
176
+            while($row = $query->fetch()) {
177
+                $names[] = $row['owncloud_name'];
178
+            }
179
+        }
180
+        return $names;
181
+    }
182 182
 
183
-	/**
184
-	 * Gets the name based on the provided LDAP UUID.
185
-	 * @param string $uuid
186
-	 * @return string|false
187
-	 */
188
-	public function getNameByUUID($uuid) {
189
-		return $this->getXbyY('owncloud_name', 'directory_uuid', $uuid);
190
-	}
183
+    /**
184
+     * Gets the name based on the provided LDAP UUID.
185
+     * @param string $uuid
186
+     * @return string|false
187
+     */
188
+    public function getNameByUUID($uuid) {
189
+        return $this->getXbyY('owncloud_name', 'directory_uuid', $uuid);
190
+    }
191 191
 
192
-	/**
193
-	 * Gets the UUID based on the provided LDAP DN
194
-	 * @param string $dn
195
-	 * @return false|string
196
-	 * @throws \Exception
197
-	 */
198
-	public function getUUIDByDN($dn) {
199
-		return $this->getXbyY('directory_uuid', 'ldap_dn', $dn);
200
-	}
192
+    /**
193
+     * Gets the UUID based on the provided LDAP DN
194
+     * @param string $dn
195
+     * @return false|string
196
+     * @throws \Exception
197
+     */
198
+    public function getUUIDByDN($dn) {
199
+        return $this->getXbyY('directory_uuid', 'ldap_dn', $dn);
200
+    }
201 201
 
202
-	/**
203
-	 * gets a piece of the mapping list
204
-	 * @param int $offset
205
-	 * @param int $limit
206
-	 * @return array
207
-	 */
208
-	public function getList($offset = null, $limit = null) {
209
-		$query = $this->dbc->prepare('
202
+    /**
203
+     * gets a piece of the mapping list
204
+     * @param int $offset
205
+     * @param int $limit
206
+     * @return array
207
+     */
208
+    public function getList($offset = null, $limit = null) {
209
+        $query = $this->dbc->prepare('
210 210
 			SELECT
211 211
 				`ldap_dn` AS `dn`,
212 212
 				`owncloud_name` AS `name`,
213 213
 				`directory_uuid` AS `uuid`
214 214
 			FROM `' . $this->getTableName() . '`',
215
-			$limit,
216
-			$offset
217
-		);
215
+            $limit,
216
+            $offset
217
+        );
218 218
 
219
-		$query->execute();
220
-		return $query->fetchAll();
221
-	}
219
+        $query->execute();
220
+        return $query->fetchAll();
221
+    }
222 222
 
223
-	/**
224
-	 * attempts to map the given entry
225
-	 * @param string $fdn fully distinguished name (from LDAP)
226
-	 * @param string $name
227
-	 * @param string $uuid a unique identifier as used in LDAP
228
-	 * @return bool
229
-	 */
230
-	public function map($fdn, $name, $uuid) {
231
-		if(mb_strlen($fdn) > 255) {
232
-			\OC::$server->getLogger()->error(
233
-				'Cannot map, because the DN exceeds 255 characters: {dn}',
234
-				[
235
-					'app' => 'user_ldap',
236
-					'dn' => $fdn,
237
-				]
238
-			);
239
-			return false;
240
-		}
223
+    /**
224
+     * attempts to map the given entry
225
+     * @param string $fdn fully distinguished name (from LDAP)
226
+     * @param string $name
227
+     * @param string $uuid a unique identifier as used in LDAP
228
+     * @return bool
229
+     */
230
+    public function map($fdn, $name, $uuid) {
231
+        if(mb_strlen($fdn) > 255) {
232
+            \OC::$server->getLogger()->error(
233
+                'Cannot map, because the DN exceeds 255 characters: {dn}',
234
+                [
235
+                    'app' => 'user_ldap',
236
+                    'dn' => $fdn,
237
+                ]
238
+            );
239
+            return false;
240
+        }
241 241
 
242
-		$row = array(
243
-			'ldap_dn'        => $fdn,
244
-			'owncloud_name'  => $name,
245
-			'directory_uuid' => $uuid
246
-		);
242
+        $row = array(
243
+            'ldap_dn'        => $fdn,
244
+            'owncloud_name'  => $name,
245
+            'directory_uuid' => $uuid
246
+        );
247 247
 
248
-		try {
249
-			$result = $this->dbc->insertIfNotExist($this->getTableName(), $row);
250
-			// insertIfNotExist returns values as int
251
-			return (bool)$result;
252
-		} catch (\Exception $e) {
253
-			return false;
254
-		}
255
-	}
248
+        try {
249
+            $result = $this->dbc->insertIfNotExist($this->getTableName(), $row);
250
+            // insertIfNotExist returns values as int
251
+            return (bool)$result;
252
+        } catch (\Exception $e) {
253
+            return false;
254
+        }
255
+    }
256 256
 
257
-	/**
258
-	 * removes a mapping based on the owncloud_name of the entry
259
-	 * @param string $name
260
-	 * @return bool
261
-	 */
262
-	public function unmap($name) {
263
-		$query = $this->dbc->prepare('
257
+    /**
258
+     * removes a mapping based on the owncloud_name of the entry
259
+     * @param string $name
260
+     * @return bool
261
+     */
262
+    public function unmap($name) {
263
+        $query = $this->dbc->prepare('
264 264
 			DELETE FROM `'. $this->getTableName() .'`
265 265
 			WHERE `owncloud_name` = ?');
266 266
 
267
-		return $this->modify($query, array($name));
268
-	}
267
+        return $this->modify($query, array($name));
268
+    }
269 269
 
270
-	/**
271
-	 * Truncate's the mapping table
272
-	 * @return bool
273
-	 */
274
-	public function clear() {
275
-		$sql = $this->dbc
276
-			->getDatabasePlatform()
277
-			->getTruncateTableSQL('`' . $this->getTableName() . '`');
278
-		return $this->dbc->prepare($sql)->execute();
279
-	}
270
+    /**
271
+     * Truncate's the mapping table
272
+     * @return bool
273
+     */
274
+    public function clear() {
275
+        $sql = $this->dbc
276
+            ->getDatabasePlatform()
277
+            ->getTruncateTableSQL('`' . $this->getTableName() . '`');
278
+        return $this->dbc->prepare($sql)->execute();
279
+    }
280 280
 }
Please login to merge, or discard this patch.
Spacing   +16 added lines, -16 removed lines patch added patch discarded remove patch
@@ -53,7 +53,7 @@  discard block
 block discarded – undo
53 53
 	 * @return bool
54 54
 	 */
55 55
 	public function isColNameValid($col) {
56
-		switch($col) {
56
+		switch ($col) {
57 57
 			case 'ldap_dn':
58 58
 			case 'owncloud_name':
59 59
 			case 'directory_uuid':
@@ -72,19 +72,19 @@  discard block
 block discarded – undo
72 72
 	 * @return string|false
73 73
 	 */
74 74
 	protected function getXbyY($fetchCol, $compareCol, $search) {
75
-		if(!$this->isColNameValid($fetchCol)) {
75
+		if (!$this->isColNameValid($fetchCol)) {
76 76
 			//this is used internally only, but we don't want to risk
77 77
 			//having SQL injection at all.
78 78
 			throw new \Exception('Invalid Column Name');
79 79
 		}
80 80
 		$query = $this->dbc->prepare('
81
-			SELECT `' . $fetchCol . '`
82
-			FROM `'. $this->getTableName() .'`
83
-			WHERE `' . $compareCol . '` = ?
81
+			SELECT `' . $fetchCol.'`
82
+			FROM `'. $this->getTableName().'`
83
+			WHERE `' . $compareCol.'` = ?
84 84
 		');
85 85
 
86 86
 		$res = $query->execute(array($search));
87
-		if($res !== false) {
87
+		if ($res !== false) {
88 88
 			return $query->fetchColumn();
89 89
 		}
90 90
 
@@ -120,7 +120,7 @@  discard block
 block discarded – undo
120 120
 	 */
121 121
 	public function setDNbyUUID($fdn, $uuid) {
122 122
 		$query = $this->dbc->prepare('
123
-			UPDATE `' . $this->getTableName() . '`
123
+			UPDATE `' . $this->getTableName().'`
124 124
 			SET `ldap_dn` = ?
125 125
 			WHERE `directory_uuid` = ?
126 126
 		');
@@ -139,7 +139,7 @@  discard block
 block discarded – undo
139 139
 	 */
140 140
 	public function setUUIDbyDN($uuid, $fdn) {
141 141
 		$query = $this->dbc->prepare('
142
-			UPDATE `' . $this->getTableName() . '`
142
+			UPDATE `' . $this->getTableName().'`
143 143
 			SET `directory_uuid` = ?
144 144
 			WHERE `ldap_dn` = ?
145 145
 		');
@@ -166,14 +166,14 @@  discard block
 block discarded – undo
166 166
 	public function getNamesBySearch($search, $prefixMatch = "", $postfixMatch = "") {
167 167
 		$query = $this->dbc->prepare('
168 168
 			SELECT `owncloud_name`
169
-			FROM `'. $this->getTableName() .'`
169
+			FROM `'. $this->getTableName().'`
170 170
 			WHERE `owncloud_name` LIKE ?
171 171
 		');
172 172
 
173 173
 		$res = $query->execute(array($prefixMatch.$this->dbc->escapeLikeParameter($search).$postfixMatch));
174 174
 		$names = array();
175
-		if($res !== false) {
176
-			while($row = $query->fetch()) {
175
+		if ($res !== false) {
176
+			while ($row = $query->fetch()) {
177 177
 				$names[] = $row['owncloud_name'];
178 178
 			}
179 179
 		}
@@ -211,7 +211,7 @@  discard block
 block discarded – undo
211 211
 				`ldap_dn` AS `dn`,
212 212
 				`owncloud_name` AS `name`,
213 213
 				`directory_uuid` AS `uuid`
214
-			FROM `' . $this->getTableName() . '`',
214
+			FROM `' . $this->getTableName().'`',
215 215
 			$limit,
216 216
 			$offset
217 217
 		);
@@ -228,7 +228,7 @@  discard block
 block discarded – undo
228 228
 	 * @return bool
229 229
 	 */
230 230
 	public function map($fdn, $name, $uuid) {
231
-		if(mb_strlen($fdn) > 255) {
231
+		if (mb_strlen($fdn) > 255) {
232 232
 			\OC::$server->getLogger()->error(
233 233
 				'Cannot map, because the DN exceeds 255 characters: {dn}',
234 234
 				[
@@ -248,7 +248,7 @@  discard block
 block discarded – undo
248 248
 		try {
249 249
 			$result = $this->dbc->insertIfNotExist($this->getTableName(), $row);
250 250
 			// insertIfNotExist returns values as int
251
-			return (bool)$result;
251
+			return (bool) $result;
252 252
 		} catch (\Exception $e) {
253 253
 			return false;
254 254
 		}
@@ -261,7 +261,7 @@  discard block
 block discarded – undo
261 261
 	 */
262 262
 	public function unmap($name) {
263 263
 		$query = $this->dbc->prepare('
264
-			DELETE FROM `'. $this->getTableName() .'`
264
+			DELETE FROM `'. $this->getTableName().'`
265 265
 			WHERE `owncloud_name` = ?');
266 266
 
267 267
 		return $this->modify($query, array($name));
@@ -274,7 +274,7 @@  discard block
 block discarded – undo
274 274
 	public function clear() {
275 275
 		$sql = $this->dbc
276 276
 			->getDatabasePlatform()
277
-			->getTruncateTableSQL('`' . $this->getTableName() . '`');
277
+			->getTruncateTableSQL('`'.$this->getTableName().'`');
278 278
 		return $this->dbc->prepare($sql)->execute();
279 279
 	}
280 280
 }
Please login to merge, or discard this patch.
apps/user_ldap/lib/Group_Proxy.php 2 patches
Indentation   +178 added lines, -178 removed lines patch added patch discarded remove patch
@@ -27,182 +27,182 @@
 block discarded – undo
27 27
 namespace OCA\User_LDAP;
28 28
 
29 29
 class Group_Proxy extends Proxy implements \OCP\GroupInterface {
30
-	private $backends = array();
31
-	private $refBackend = null;
32
-
33
-	/**
34
-	 * Constructor
35
-	 * @param string[] $serverConfigPrefixes array containing the config Prefixes
36
-	 */
37
-	public function __construct($serverConfigPrefixes, ILDAPWrapper $ldap) {
38
-		parent::__construct($ldap);
39
-		foreach($serverConfigPrefixes as $configPrefix) {
40
-			$this->backends[$configPrefix] =
41
-				new \OCA\User_LDAP\Group_LDAP($this->getAccess($configPrefix));
42
-			if(is_null($this->refBackend)) {
43
-				$this->refBackend = &$this->backends[$configPrefix];
44
-			}
45
-		}
46
-	}
47
-
48
-	/**
49
-	 * Tries the backends one after the other until a positive result is returned from the specified method
50
-	 * @param string $gid the gid connected to the request
51
-	 * @param string $method the method of the group backend that shall be called
52
-	 * @param array $parameters an array of parameters to be passed
53
-	 * @return mixed, the result of the method or false
54
-	 */
55
-	protected function walkBackends($gid, $method, $parameters) {
56
-		$cacheKey = $this->getGroupCacheKey($gid);
57
-		foreach($this->backends as $configPrefix => $backend) {
58
-			if($result = call_user_func_array(array($backend, $method), $parameters)) {
59
-				$this->writeToCache($cacheKey, $configPrefix);
60
-				return $result;
61
-			}
62
-		}
63
-		return false;
64
-	}
65
-
66
-	/**
67
-	 * Asks the backend connected to the server that supposely takes care of the gid from the request.
68
-	 * @param string $gid the gid connected to the request
69
-	 * @param string $method the method of the group backend that shall be called
70
-	 * @param array $parameters an array of parameters to be passed
71
-	 * @param mixed $passOnWhen the result matches this variable
72
-	 * @return mixed, the result of the method or false
73
-	 */
74
-	protected function callOnLastSeenOn($gid, $method, $parameters, $passOnWhen) {
75
-		$cacheKey = $this->getGroupCacheKey($gid);;
76
-		$prefix = $this->getFromCache($cacheKey);
77
-		//in case the uid has been found in the past, try this stored connection first
78
-		if(!is_null($prefix)) {
79
-			if(isset($this->backends[$prefix])) {
80
-				$result = call_user_func_array(array($this->backends[$prefix], $method), $parameters);
81
-				if($result === $passOnWhen) {
82
-					//not found here, reset cache to null if group vanished
83
-					//because sometimes methods return false with a reason
84
-					$groupExists = call_user_func_array(
85
-						array($this->backends[$prefix], 'groupExists'),
86
-						array($gid)
87
-					);
88
-					if(!$groupExists) {
89
-						$this->writeToCache($cacheKey, null);
90
-					}
91
-				}
92
-				return $result;
93
-			}
94
-		}
95
-		return false;
96
-	}
97
-
98
-	/**
99
-	 * is user in group?
100
-	 * @param string $uid uid of the user
101
-	 * @param string $gid gid of the group
102
-	 * @return bool
103
-	 *
104
-	 * Checks whether the user is member of a group or not.
105
-	 */
106
-	public function inGroup($uid, $gid) {
107
-		return $this->handleRequest($gid, 'inGroup', array($uid, $gid));
108
-	}
109
-
110
-	/**
111
-	 * Get all groups a user belongs to
112
-	 * @param string $uid Name of the user
113
-	 * @return string[] with group names
114
-	 *
115
-	 * This function fetches all groups a user belongs to. It does not check
116
-	 * if the user exists at all.
117
-	 */
118
-	public function getUserGroups($uid) {
119
-		$groups = array();
120
-
121
-		foreach($this->backends as $backend) {
122
-			$backendGroups = $backend->getUserGroups($uid);
123
-			if (is_array($backendGroups)) {
124
-				$groups = array_merge($groups, $backendGroups);
125
-			}
126
-		}
127
-
128
-		return $groups;
129
-	}
130
-
131
-	/**
132
-	 * get a list of all users in a group
133
-	 * @return string[] with user ids
134
-	 */
135
-	public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
136
-		$users = array();
137
-
138
-		foreach($this->backends as $backend) {
139
-			$backendUsers = $backend->usersInGroup($gid, $search, $limit, $offset);
140
-			if (is_array($backendUsers)) {
141
-				$users = array_merge($users, $backendUsers);
142
-			}
143
-		}
144
-
145
-		return $users;
146
-	}
147
-
148
-	/**
149
-	 * returns the number of users in a group, who match the search term
150
-	 * @param string $gid the internal group name
151
-	 * @param string $search optional, a search string
152
-	 * @return int|bool
153
-	 */
154
-	public function countUsersInGroup($gid, $search = '') {
155
-		return $this->handleRequest(
156
-			$gid, 'countUsersInGroup', array($gid, $search));
157
-	}
158
-
159
-	/**
160
-	 * get a list of all groups
161
-	 * @return string[] with group names
162
-	 *
163
-	 * Returns a list with all groups
164
-	 */
165
-	public function getGroups($search = '', $limit = -1, $offset = 0) {
166
-		$groups = array();
167
-
168
-		foreach($this->backends as $backend) {
169
-			$backendGroups = $backend->getGroups($search, $limit, $offset);
170
-			if (is_array($backendGroups)) {
171
-				$groups = array_merge($groups, $backendGroups);
172
-			}
173
-		}
174
-
175
-		return $groups;
176
-	}
177
-
178
-	/**
179
-	 * check if a group exists
180
-	 * @param string $gid
181
-	 * @return bool
182
-	 */
183
-	public function groupExists($gid) {
184
-		return $this->handleRequest($gid, 'groupExists', array($gid));
185
-	}
186
-
187
-	/**
188
-	 * Check if backend implements actions
189
-	 * @param int $actions bitwise-or'ed actions
190
-	 * @return boolean
191
-	 *
192
-	 * Returns the supported actions as int to be
193
-	 * compared with OC_USER_BACKEND_CREATE_USER etc.
194
-	 */
195
-	public function implementsActions($actions) {
196
-		//it's the same across all our user backends obviously
197
-		return $this->refBackend->implementsActions($actions);
198
-	}
199
-
200
-	/**
201
-	 * Return access for LDAP interaction.
202
-	 * @param string $gid
203
-	 * @return Access instance of Access for LDAP interaction
204
-	 */
205
-	public function getLDAPAccess($gid) {
206
-		return $this->handleRequest($gid, 'getLDAPAccess', []);
207
-	}
30
+    private $backends = array();
31
+    private $refBackend = null;
32
+
33
+    /**
34
+     * Constructor
35
+     * @param string[] $serverConfigPrefixes array containing the config Prefixes
36
+     */
37
+    public function __construct($serverConfigPrefixes, ILDAPWrapper $ldap) {
38
+        parent::__construct($ldap);
39
+        foreach($serverConfigPrefixes as $configPrefix) {
40
+            $this->backends[$configPrefix] =
41
+                new \OCA\User_LDAP\Group_LDAP($this->getAccess($configPrefix));
42
+            if(is_null($this->refBackend)) {
43
+                $this->refBackend = &$this->backends[$configPrefix];
44
+            }
45
+        }
46
+    }
47
+
48
+    /**
49
+     * Tries the backends one after the other until a positive result is returned from the specified method
50
+     * @param string $gid the gid connected to the request
51
+     * @param string $method the method of the group backend that shall be called
52
+     * @param array $parameters an array of parameters to be passed
53
+     * @return mixed, the result of the method or false
54
+     */
55
+    protected function walkBackends($gid, $method, $parameters) {
56
+        $cacheKey = $this->getGroupCacheKey($gid);
57
+        foreach($this->backends as $configPrefix => $backend) {
58
+            if($result = call_user_func_array(array($backend, $method), $parameters)) {
59
+                $this->writeToCache($cacheKey, $configPrefix);
60
+                return $result;
61
+            }
62
+        }
63
+        return false;
64
+    }
65
+
66
+    /**
67
+     * Asks the backend connected to the server that supposely takes care of the gid from the request.
68
+     * @param string $gid the gid connected to the request
69
+     * @param string $method the method of the group backend that shall be called
70
+     * @param array $parameters an array of parameters to be passed
71
+     * @param mixed $passOnWhen the result matches this variable
72
+     * @return mixed, the result of the method or false
73
+     */
74
+    protected function callOnLastSeenOn($gid, $method, $parameters, $passOnWhen) {
75
+        $cacheKey = $this->getGroupCacheKey($gid);;
76
+        $prefix = $this->getFromCache($cacheKey);
77
+        //in case the uid has been found in the past, try this stored connection first
78
+        if(!is_null($prefix)) {
79
+            if(isset($this->backends[$prefix])) {
80
+                $result = call_user_func_array(array($this->backends[$prefix], $method), $parameters);
81
+                if($result === $passOnWhen) {
82
+                    //not found here, reset cache to null if group vanished
83
+                    //because sometimes methods return false with a reason
84
+                    $groupExists = call_user_func_array(
85
+                        array($this->backends[$prefix], 'groupExists'),
86
+                        array($gid)
87
+                    );
88
+                    if(!$groupExists) {
89
+                        $this->writeToCache($cacheKey, null);
90
+                    }
91
+                }
92
+                return $result;
93
+            }
94
+        }
95
+        return false;
96
+    }
97
+
98
+    /**
99
+     * is user in group?
100
+     * @param string $uid uid of the user
101
+     * @param string $gid gid of the group
102
+     * @return bool
103
+     *
104
+     * Checks whether the user is member of a group or not.
105
+     */
106
+    public function inGroup($uid, $gid) {
107
+        return $this->handleRequest($gid, 'inGroup', array($uid, $gid));
108
+    }
109
+
110
+    /**
111
+     * Get all groups a user belongs to
112
+     * @param string $uid Name of the user
113
+     * @return string[] with group names
114
+     *
115
+     * This function fetches all groups a user belongs to. It does not check
116
+     * if the user exists at all.
117
+     */
118
+    public function getUserGroups($uid) {
119
+        $groups = array();
120
+
121
+        foreach($this->backends as $backend) {
122
+            $backendGroups = $backend->getUserGroups($uid);
123
+            if (is_array($backendGroups)) {
124
+                $groups = array_merge($groups, $backendGroups);
125
+            }
126
+        }
127
+
128
+        return $groups;
129
+    }
130
+
131
+    /**
132
+     * get a list of all users in a group
133
+     * @return string[] with user ids
134
+     */
135
+    public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
136
+        $users = array();
137
+
138
+        foreach($this->backends as $backend) {
139
+            $backendUsers = $backend->usersInGroup($gid, $search, $limit, $offset);
140
+            if (is_array($backendUsers)) {
141
+                $users = array_merge($users, $backendUsers);
142
+            }
143
+        }
144
+
145
+        return $users;
146
+    }
147
+
148
+    /**
149
+     * returns the number of users in a group, who match the search term
150
+     * @param string $gid the internal group name
151
+     * @param string $search optional, a search string
152
+     * @return int|bool
153
+     */
154
+    public function countUsersInGroup($gid, $search = '') {
155
+        return $this->handleRequest(
156
+            $gid, 'countUsersInGroup', array($gid, $search));
157
+    }
158
+
159
+    /**
160
+     * get a list of all groups
161
+     * @return string[] with group names
162
+     *
163
+     * Returns a list with all groups
164
+     */
165
+    public function getGroups($search = '', $limit = -1, $offset = 0) {
166
+        $groups = array();
167
+
168
+        foreach($this->backends as $backend) {
169
+            $backendGroups = $backend->getGroups($search, $limit, $offset);
170
+            if (is_array($backendGroups)) {
171
+                $groups = array_merge($groups, $backendGroups);
172
+            }
173
+        }
174
+
175
+        return $groups;
176
+    }
177
+
178
+    /**
179
+     * check if a group exists
180
+     * @param string $gid
181
+     * @return bool
182
+     */
183
+    public function groupExists($gid) {
184
+        return $this->handleRequest($gid, 'groupExists', array($gid));
185
+    }
186
+
187
+    /**
188
+     * Check if backend implements actions
189
+     * @param int $actions bitwise-or'ed actions
190
+     * @return boolean
191
+     *
192
+     * Returns the supported actions as int to be
193
+     * compared with OC_USER_BACKEND_CREATE_USER etc.
194
+     */
195
+    public function implementsActions($actions) {
196
+        //it's the same across all our user backends obviously
197
+        return $this->refBackend->implementsActions($actions);
198
+    }
199
+
200
+    /**
201
+     * Return access for LDAP interaction.
202
+     * @param string $gid
203
+     * @return Access instance of Access for LDAP interaction
204
+     */
205
+    public function getLDAPAccess($gid) {
206
+        return $this->handleRequest($gid, 'getLDAPAccess', []);
207
+    }
208 208
 }
Please login to merge, or discard this patch.
Spacing   +12 added lines, -12 removed lines patch added patch discarded remove patch
@@ -36,10 +36,10 @@  discard block
 block discarded – undo
36 36
 	 */
37 37
 	public function __construct($serverConfigPrefixes, ILDAPWrapper $ldap) {
38 38
 		parent::__construct($ldap);
39
-		foreach($serverConfigPrefixes as $configPrefix) {
39
+		foreach ($serverConfigPrefixes as $configPrefix) {
40 40
 			$this->backends[$configPrefix] =
41 41
 				new \OCA\User_LDAP\Group_LDAP($this->getAccess($configPrefix));
42
-			if(is_null($this->refBackend)) {
42
+			if (is_null($this->refBackend)) {
43 43
 				$this->refBackend = &$this->backends[$configPrefix];
44 44
 			}
45 45
 		}
@@ -54,8 +54,8 @@  discard block
 block discarded – undo
54 54
 	 */
55 55
 	protected function walkBackends($gid, $method, $parameters) {
56 56
 		$cacheKey = $this->getGroupCacheKey($gid);
57
-		foreach($this->backends as $configPrefix => $backend) {
58
-			if($result = call_user_func_array(array($backend, $method), $parameters)) {
57
+		foreach ($this->backends as $configPrefix => $backend) {
58
+			if ($result = call_user_func_array(array($backend, $method), $parameters)) {
59 59
 				$this->writeToCache($cacheKey, $configPrefix);
60 60
 				return $result;
61 61
 			}
@@ -72,20 +72,20 @@  discard block
 block discarded – undo
72 72
 	 * @return mixed, the result of the method or false
73 73
 	 */
74 74
 	protected function callOnLastSeenOn($gid, $method, $parameters, $passOnWhen) {
75
-		$cacheKey = $this->getGroupCacheKey($gid);;
75
+		$cacheKey = $this->getGroupCacheKey($gid); ;
76 76
 		$prefix = $this->getFromCache($cacheKey);
77 77
 		//in case the uid has been found in the past, try this stored connection first
78
-		if(!is_null($prefix)) {
79
-			if(isset($this->backends[$prefix])) {
78
+		if (!is_null($prefix)) {
79
+			if (isset($this->backends[$prefix])) {
80 80
 				$result = call_user_func_array(array($this->backends[$prefix], $method), $parameters);
81
-				if($result === $passOnWhen) {
81
+				if ($result === $passOnWhen) {
82 82
 					//not found here, reset cache to null if group vanished
83 83
 					//because sometimes methods return false with a reason
84 84
 					$groupExists = call_user_func_array(
85 85
 						array($this->backends[$prefix], 'groupExists'),
86 86
 						array($gid)
87 87
 					);
88
-					if(!$groupExists) {
88
+					if (!$groupExists) {
89 89
 						$this->writeToCache($cacheKey, null);
90 90
 					}
91 91
 				}
@@ -118,7 +118,7 @@  discard block
 block discarded – undo
118 118
 	public function getUserGroups($uid) {
119 119
 		$groups = array();
120 120
 
121
-		foreach($this->backends as $backend) {
121
+		foreach ($this->backends as $backend) {
122 122
 			$backendGroups = $backend->getUserGroups($uid);
123 123
 			if (is_array($backendGroups)) {
124 124
 				$groups = array_merge($groups, $backendGroups);
@@ -135,7 +135,7 @@  discard block
 block discarded – undo
135 135
 	public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
136 136
 		$users = array();
137 137
 
138
-		foreach($this->backends as $backend) {
138
+		foreach ($this->backends as $backend) {
139 139
 			$backendUsers = $backend->usersInGroup($gid, $search, $limit, $offset);
140 140
 			if (is_array($backendUsers)) {
141 141
 				$users = array_merge($users, $backendUsers);
@@ -165,7 +165,7 @@  discard block
 block discarded – undo
165 165
 	public function getGroups($search = '', $limit = -1, $offset = 0) {
166 166
 		$groups = array();
167 167
 
168
-		foreach($this->backends as $backend) {
168
+		foreach ($this->backends as $backend) {
169 169
 			$backendGroups = $backend->getGroups($search, $limit, $offset);
170 170
 			if (is_array($backendGroups)) {
171 171
 				$groups = array_merge($groups, $backendGroups);
Please login to merge, or discard this patch.
apps/user_ldap/lib/LDAP.php 2 patches
Indentation   +337 added lines, -337 removed lines patch added patch discarded remove patch
@@ -33,341 +33,341 @@
 block discarded – undo
33 33
 use OCA\User_LDAP\Exceptions\ConstraintViolationException;
34 34
 
35 35
 class LDAP implements ILDAPWrapper {
36
-	protected $curFunc = '';
37
-	protected $curArgs = array();
38
-
39
-	/**
40
-	 * @param resource $link
41
-	 * @param string $dn
42
-	 * @param string $password
43
-	 * @return bool|mixed
44
-	 */
45
-	public function bind($link, $dn, $password) {
46
-		return $this->invokeLDAPMethod('bind', $link, $dn, $password);
47
-	}
48
-
49
-	/**
50
-	 * @param string $host
51
-	 * @param string $port
52
-	 * @return mixed
53
-	 */
54
-	public function connect($host, $port) {
55
-		if(strpos($host, '://') === false) {
56
-			$host = 'ldap://' . $host;
57
-		}
58
-		if(strpos($host, ':', strpos($host, '://') + 1) === false) {
59
-			//ldap_connect ignores port parameter when URLs are passed
60
-			$host .= ':' . $port;
61
-		}
62
-		return $this->invokeLDAPMethod('connect', $host);
63
-	}
64
-
65
-	/**
66
-	 * @param LDAP $link
67
-	 * @param LDAP $result
68
-	 * @param string $cookie
69
-	 * @return bool|LDAP
70
-	 */
71
-	public function controlPagedResultResponse($link, $result, &$cookie) {
72
-		$this->preFunctionCall('ldap_control_paged_result_response',
73
-			array($link, $result, $cookie));
74
-		$result = ldap_control_paged_result_response($link, $result, $cookie);
75
-		$this->postFunctionCall();
76
-
77
-		return $result;
78
-	}
79
-
80
-	/**
81
-	 * @param LDAP $link
82
-	 * @param int $pageSize
83
-	 * @param bool $isCritical
84
-	 * @param string $cookie
85
-	 * @return mixed|true
86
-	 */
87
-	public function controlPagedResult($link, $pageSize, $isCritical, $cookie) {
88
-		return $this->invokeLDAPMethod('control_paged_result', $link, $pageSize,
89
-										$isCritical, $cookie);
90
-	}
91
-
92
-	/**
93
-	 * @param LDAP $link
94
-	 * @param LDAP $result
95
-	 * @return mixed
96
-	 */
97
-	public function countEntries($link, $result) {
98
-		return $this->invokeLDAPMethod('count_entries', $link, $result);
99
-	}
100
-
101
-	/**
102
-	 * @param LDAP $link
103
-	 * @return mixed|string
104
-	 */
105
-	public function errno($link) {
106
-		return $this->invokeLDAPMethod('errno', $link);
107
-	}
108
-
109
-	/**
110
-	 * @param LDAP $link
111
-	 * @return int|mixed
112
-	 */
113
-	public function error($link) {
114
-		return $this->invokeLDAPMethod('error', $link);
115
-	}
116
-
117
-	/**
118
-	 * Splits DN into its component parts
119
-	 * @param string $dn
120
-	 * @param int @withAttrib
121
-	 * @return array|false
122
-	 * @link http://www.php.net/manual/en/function.ldap-explode-dn.php
123
-	 */
124
-	public function explodeDN($dn, $withAttrib) {
125
-		return $this->invokeLDAPMethod('explode_dn', $dn, $withAttrib);
126
-	}
127
-
128
-	/**
129
-	 * @param LDAP $link
130
-	 * @param LDAP $result
131
-	 * @return mixed
132
-	 */
133
-	public function firstEntry($link, $result) {
134
-		return $this->invokeLDAPMethod('first_entry', $link, $result);
135
-	}
136
-
137
-	/**
138
-	 * @param LDAP $link
139
-	 * @param LDAP $result
140
-	 * @return array|mixed
141
-	 */
142
-	public function getAttributes($link, $result) {
143
-		return $this->invokeLDAPMethod('get_attributes', $link, $result);
144
-	}
145
-
146
-	/**
147
-	 * @param LDAP $link
148
-	 * @param LDAP $result
149
-	 * @return mixed|string
150
-	 */
151
-	public function getDN($link, $result) {
152
-		return $this->invokeLDAPMethod('get_dn', $link, $result);
153
-	}
154
-
155
-	/**
156
-	 * @param LDAP $link
157
-	 * @param LDAP $result
158
-	 * @return array|mixed
159
-	 */
160
-	public function getEntries($link, $result) {
161
-		return $this->invokeLDAPMethod('get_entries', $link, $result);
162
-	}
163
-
164
-	/**
165
-	 * @param LDAP $link
166
-	 * @param resource $result
167
-	 * @return mixed
168
-	 */
169
-	public function nextEntry($link, $result) {
170
-		return $this->invokeLDAPMethod('next_entry', $link, $result);
171
-	}
172
-
173
-	/**
174
-	 * @param LDAP $link
175
-	 * @param string $baseDN
176
-	 * @param string $filter
177
-	 * @param array $attr
178
-	 * @return mixed
179
-	 */
180
-	public function read($link, $baseDN, $filter, $attr) {
181
-		return $this->invokeLDAPMethod('read', $link, $baseDN, $filter, $attr);
182
-	}
183
-
184
-	/**
185
-	 * @param LDAP $link
186
-	 * @param string $baseDN
187
-	 * @param string $filter
188
-	 * @param array $attr
189
-	 * @param int $attrsOnly
190
-	 * @param int $limit
191
-	 * @return mixed
192
-	 */
193
-	public function search($link, $baseDN, $filter, $attr, $attrsOnly = 0, $limit = 0) {
194
-		return $this->invokeLDAPMethod('search', $link, $baseDN, $filter, $attr, $attrsOnly, $limit);
195
-	}
196
-
197
-	/**
198
-	 * @param LDAP $link
199
-	 * @param string $userDN
200
-	 * @param string $password
201
-	 * @return bool
202
-	 */
203
-	public function modReplace($link, $userDN, $password) {
204
-		return $this->invokeLDAPMethod('mod_replace', $link, $userDN, array('userPassword' => $password));
205
-	}
206
-
207
-	/**
208
-	 * @param LDAP $link
209
-	 * @param string $option
210
-	 * @param int $value
211
-	 * @return bool|mixed
212
-	 */
213
-	public function setOption($link, $option, $value) {
214
-		return $this->invokeLDAPMethod('set_option', $link, $option, $value);
215
-	}
216
-
217
-	/**
218
-	 * @param LDAP $link
219
-	 * @return mixed|true
220
-	 */
221
-	public function startTls($link) {
222
-		return $this->invokeLDAPMethod('start_tls', $link);
223
-	}
224
-
225
-	/**
226
-	 * @param resource $link
227
-	 * @return bool|mixed
228
-	 */
229
-	public function unbind($link) {
230
-		return $this->invokeLDAPMethod('unbind', $link);
231
-	}
232
-
233
-	/**
234
-	 * Checks whether the server supports LDAP
235
-	 * @return boolean if it the case, false otherwise
236
-	 * */
237
-	public function areLDAPFunctionsAvailable() {
238
-		return function_exists('ldap_connect');
239
-	}
240
-
241
-	/**
242
-	 * Checks whether PHP supports LDAP Paged Results
243
-	 * @return boolean if it the case, false otherwise
244
-	 * */
245
-	public function hasPagedResultSupport() {
246
-		$hasSupport = function_exists('ldap_control_paged_result')
247
-			&& function_exists('ldap_control_paged_result_response');
248
-		return $hasSupport;
249
-	}
250
-
251
-	/**
252
-	 * Checks whether the submitted parameter is a resource
253
-	 * @param Resource $resource the resource variable to check
254
-	 * @return bool true if it is a resource, false otherwise
255
-	 */
256
-	public function isResource($resource) {
257
-		return is_resource($resource);
258
-	}
259
-
260
-	/**
261
-	 * Checks whether the return value from LDAP is wrong or not.
262
-	 *
263
-	 * When using ldap_search we provide an array, in case multiple bases are
264
-	 * configured. Thus, we need to check the array elements.
265
-	 *
266
-	 * @param $result
267
-	 * @return bool
268
-	 */
269
-	protected function isResultFalse($result) {
270
-		if($result === false) {
271
-			return true;
272
-		}
273
-
274
-		if($this->curFunc === 'ldap_search' && is_array($result)) {
275
-			foreach ($result as $singleResult) {
276
-				if($singleResult === false) {
277
-					return true;
278
-				}
279
-			}
280
-		}
281
-
282
-		return false;
283
-	}
284
-
285
-	/**
286
-	 * @return mixed
287
-	 */
288
-	protected function invokeLDAPMethod() {
289
-		$arguments = func_get_args();
290
-		$func = 'ldap_' . array_shift($arguments);
291
-		if(function_exists($func)) {
292
-			$this->preFunctionCall($func, $arguments);
293
-			$result = call_user_func_array($func, $arguments);
294
-			if ($this->isResultFalse($result)) {
295
-				$this->postFunctionCall();
296
-			}
297
-			return $result;
298
-		}
299
-		return null;
300
-	}
301
-
302
-	/**
303
-	 * @param string $functionName
304
-	 * @param array $args
305
-	 */
306
-	private function preFunctionCall($functionName, $args) {
307
-		$this->curFunc = $functionName;
308
-		$this->curArgs = $args;
309
-	}
310
-
311
-	/**
312
-	 * Analyzes the returned LDAP error and acts accordingly if not 0
313
-	 *
314
-	 * @param resource $resource the LDAP Connection resource
315
-	 * @throws ConstraintViolationException
316
-	 * @throws ServerNotAvailableException
317
-	 * @throws \Exception
318
-	 */
319
-	private function processLDAPError($resource) {
320
-		$errorCode = ldap_errno($resource);
321
-		if($errorCode === 0) {
322
-			return;
323
-		}
324
-		$errorMsg  = ldap_error($resource);
325
-
326
-		if($this->curFunc === 'ldap_get_entries'
327
-			&& $errorCode === -4) {
328
-		} else if ($errorCode === 32) {
329
-			//for now
330
-		} else if ($errorCode === 10) {
331
-			//referrals, we switch them off, but then there is AD :)
332
-		} else if ($errorCode === -1) {
333
-			throw new ServerNotAvailableException('Lost connection to LDAP server.');
334
-		} else if ($errorCode === 48) {
335
-			throw new \Exception('LDAP authentication method rejected', $errorCode);
336
-		} else if ($errorCode === 1) {
337
-			throw new \Exception('LDAP Operations error', $errorCode);
338
-		} else if ($errorCode === 19) {
339
-			ldap_get_option($this->curArgs[0], LDAP_OPT_ERROR_STRING, $extended_error);
340
-			throw new ConstraintViolationException(!empty($extended_error)?$extended_error:$errorMsg, $errorCode);
341
-		} else {
342
-			\OCP\Util::writeLog('user_ldap',
343
-				'LDAP error '.$errorMsg.' (' .
344
-				$errorCode.') after calling '.
345
-				$this->curFunc,
346
-				\OCP\Util::DEBUG);
347
-		}
348
-	}
349
-
350
-	/**
351
-	 * Called after an ldap method is run to act on LDAP error if necessary
352
-	 */
353
-	private function postFunctionCall() {
354
-		if($this->isResource($this->curArgs[0])) {
355
-			$resource = $this->curArgs[0];
356
-		} else if(
357
-			   $this->curFunc === 'ldap_search'
358
-			&& is_array($this->curArgs[0])
359
-			&& $this->isResource($this->curArgs[0][0])
360
-		) {
361
-			// we use always the same LDAP connection resource, is enough to
362
-			// take the first one.
363
-			$resource = $this->curArgs[0][0];
364
-		} else {
365
-			return;
366
-		}
367
-
368
-		$this->processLDAPError($resource);
369
-
370
-		$this->curFunc = '';
371
-		$this->curArgs = [];
372
-	}
36
+    protected $curFunc = '';
37
+    protected $curArgs = array();
38
+
39
+    /**
40
+     * @param resource $link
41
+     * @param string $dn
42
+     * @param string $password
43
+     * @return bool|mixed
44
+     */
45
+    public function bind($link, $dn, $password) {
46
+        return $this->invokeLDAPMethod('bind', $link, $dn, $password);
47
+    }
48
+
49
+    /**
50
+     * @param string $host
51
+     * @param string $port
52
+     * @return mixed
53
+     */
54
+    public function connect($host, $port) {
55
+        if(strpos($host, '://') === false) {
56
+            $host = 'ldap://' . $host;
57
+        }
58
+        if(strpos($host, ':', strpos($host, '://') + 1) === false) {
59
+            //ldap_connect ignores port parameter when URLs are passed
60
+            $host .= ':' . $port;
61
+        }
62
+        return $this->invokeLDAPMethod('connect', $host);
63
+    }
64
+
65
+    /**
66
+     * @param LDAP $link
67
+     * @param LDAP $result
68
+     * @param string $cookie
69
+     * @return bool|LDAP
70
+     */
71
+    public function controlPagedResultResponse($link, $result, &$cookie) {
72
+        $this->preFunctionCall('ldap_control_paged_result_response',
73
+            array($link, $result, $cookie));
74
+        $result = ldap_control_paged_result_response($link, $result, $cookie);
75
+        $this->postFunctionCall();
76
+
77
+        return $result;
78
+    }
79
+
80
+    /**
81
+     * @param LDAP $link
82
+     * @param int $pageSize
83
+     * @param bool $isCritical
84
+     * @param string $cookie
85
+     * @return mixed|true
86
+     */
87
+    public function controlPagedResult($link, $pageSize, $isCritical, $cookie) {
88
+        return $this->invokeLDAPMethod('control_paged_result', $link, $pageSize,
89
+                                        $isCritical, $cookie);
90
+    }
91
+
92
+    /**
93
+     * @param LDAP $link
94
+     * @param LDAP $result
95
+     * @return mixed
96
+     */
97
+    public function countEntries($link, $result) {
98
+        return $this->invokeLDAPMethod('count_entries', $link, $result);
99
+    }
100
+
101
+    /**
102
+     * @param LDAP $link
103
+     * @return mixed|string
104
+     */
105
+    public function errno($link) {
106
+        return $this->invokeLDAPMethod('errno', $link);
107
+    }
108
+
109
+    /**
110
+     * @param LDAP $link
111
+     * @return int|mixed
112
+     */
113
+    public function error($link) {
114
+        return $this->invokeLDAPMethod('error', $link);
115
+    }
116
+
117
+    /**
118
+     * Splits DN into its component parts
119
+     * @param string $dn
120
+     * @param int @withAttrib
121
+     * @return array|false
122
+     * @link http://www.php.net/manual/en/function.ldap-explode-dn.php
123
+     */
124
+    public function explodeDN($dn, $withAttrib) {
125
+        return $this->invokeLDAPMethod('explode_dn', $dn, $withAttrib);
126
+    }
127
+
128
+    /**
129
+     * @param LDAP $link
130
+     * @param LDAP $result
131
+     * @return mixed
132
+     */
133
+    public function firstEntry($link, $result) {
134
+        return $this->invokeLDAPMethod('first_entry', $link, $result);
135
+    }
136
+
137
+    /**
138
+     * @param LDAP $link
139
+     * @param LDAP $result
140
+     * @return array|mixed
141
+     */
142
+    public function getAttributes($link, $result) {
143
+        return $this->invokeLDAPMethod('get_attributes', $link, $result);
144
+    }
145
+
146
+    /**
147
+     * @param LDAP $link
148
+     * @param LDAP $result
149
+     * @return mixed|string
150
+     */
151
+    public function getDN($link, $result) {
152
+        return $this->invokeLDAPMethod('get_dn', $link, $result);
153
+    }
154
+
155
+    /**
156
+     * @param LDAP $link
157
+     * @param LDAP $result
158
+     * @return array|mixed
159
+     */
160
+    public function getEntries($link, $result) {
161
+        return $this->invokeLDAPMethod('get_entries', $link, $result);
162
+    }
163
+
164
+    /**
165
+     * @param LDAP $link
166
+     * @param resource $result
167
+     * @return mixed
168
+     */
169
+    public function nextEntry($link, $result) {
170
+        return $this->invokeLDAPMethod('next_entry', $link, $result);
171
+    }
172
+
173
+    /**
174
+     * @param LDAP $link
175
+     * @param string $baseDN
176
+     * @param string $filter
177
+     * @param array $attr
178
+     * @return mixed
179
+     */
180
+    public function read($link, $baseDN, $filter, $attr) {
181
+        return $this->invokeLDAPMethod('read', $link, $baseDN, $filter, $attr);
182
+    }
183
+
184
+    /**
185
+     * @param LDAP $link
186
+     * @param string $baseDN
187
+     * @param string $filter
188
+     * @param array $attr
189
+     * @param int $attrsOnly
190
+     * @param int $limit
191
+     * @return mixed
192
+     */
193
+    public function search($link, $baseDN, $filter, $attr, $attrsOnly = 0, $limit = 0) {
194
+        return $this->invokeLDAPMethod('search', $link, $baseDN, $filter, $attr, $attrsOnly, $limit);
195
+    }
196
+
197
+    /**
198
+     * @param LDAP $link
199
+     * @param string $userDN
200
+     * @param string $password
201
+     * @return bool
202
+     */
203
+    public function modReplace($link, $userDN, $password) {
204
+        return $this->invokeLDAPMethod('mod_replace', $link, $userDN, array('userPassword' => $password));
205
+    }
206
+
207
+    /**
208
+     * @param LDAP $link
209
+     * @param string $option
210
+     * @param int $value
211
+     * @return bool|mixed
212
+     */
213
+    public function setOption($link, $option, $value) {
214
+        return $this->invokeLDAPMethod('set_option', $link, $option, $value);
215
+    }
216
+
217
+    /**
218
+     * @param LDAP $link
219
+     * @return mixed|true
220
+     */
221
+    public function startTls($link) {
222
+        return $this->invokeLDAPMethod('start_tls', $link);
223
+    }
224
+
225
+    /**
226
+     * @param resource $link
227
+     * @return bool|mixed
228
+     */
229
+    public function unbind($link) {
230
+        return $this->invokeLDAPMethod('unbind', $link);
231
+    }
232
+
233
+    /**
234
+     * Checks whether the server supports LDAP
235
+     * @return boolean if it the case, false otherwise
236
+     * */
237
+    public function areLDAPFunctionsAvailable() {
238
+        return function_exists('ldap_connect');
239
+    }
240
+
241
+    /**
242
+     * Checks whether PHP supports LDAP Paged Results
243
+     * @return boolean if it the case, false otherwise
244
+     * */
245
+    public function hasPagedResultSupport() {
246
+        $hasSupport = function_exists('ldap_control_paged_result')
247
+            && function_exists('ldap_control_paged_result_response');
248
+        return $hasSupport;
249
+    }
250
+
251
+    /**
252
+     * Checks whether the submitted parameter is a resource
253
+     * @param Resource $resource the resource variable to check
254
+     * @return bool true if it is a resource, false otherwise
255
+     */
256
+    public function isResource($resource) {
257
+        return is_resource($resource);
258
+    }
259
+
260
+    /**
261
+     * Checks whether the return value from LDAP is wrong or not.
262
+     *
263
+     * When using ldap_search we provide an array, in case multiple bases are
264
+     * configured. Thus, we need to check the array elements.
265
+     *
266
+     * @param $result
267
+     * @return bool
268
+     */
269
+    protected function isResultFalse($result) {
270
+        if($result === false) {
271
+            return true;
272
+        }
273
+
274
+        if($this->curFunc === 'ldap_search' && is_array($result)) {
275
+            foreach ($result as $singleResult) {
276
+                if($singleResult === false) {
277
+                    return true;
278
+                }
279
+            }
280
+        }
281
+
282
+        return false;
283
+    }
284
+
285
+    /**
286
+     * @return mixed
287
+     */
288
+    protected function invokeLDAPMethod() {
289
+        $arguments = func_get_args();
290
+        $func = 'ldap_' . array_shift($arguments);
291
+        if(function_exists($func)) {
292
+            $this->preFunctionCall($func, $arguments);
293
+            $result = call_user_func_array($func, $arguments);
294
+            if ($this->isResultFalse($result)) {
295
+                $this->postFunctionCall();
296
+            }
297
+            return $result;
298
+        }
299
+        return null;
300
+    }
301
+
302
+    /**
303
+     * @param string $functionName
304
+     * @param array $args
305
+     */
306
+    private function preFunctionCall($functionName, $args) {
307
+        $this->curFunc = $functionName;
308
+        $this->curArgs = $args;
309
+    }
310
+
311
+    /**
312
+     * Analyzes the returned LDAP error and acts accordingly if not 0
313
+     *
314
+     * @param resource $resource the LDAP Connection resource
315
+     * @throws ConstraintViolationException
316
+     * @throws ServerNotAvailableException
317
+     * @throws \Exception
318
+     */
319
+    private function processLDAPError($resource) {
320
+        $errorCode = ldap_errno($resource);
321
+        if($errorCode === 0) {
322
+            return;
323
+        }
324
+        $errorMsg  = ldap_error($resource);
325
+
326
+        if($this->curFunc === 'ldap_get_entries'
327
+            && $errorCode === -4) {
328
+        } else if ($errorCode === 32) {
329
+            //for now
330
+        } else if ($errorCode === 10) {
331
+            //referrals, we switch them off, but then there is AD :)
332
+        } else if ($errorCode === -1) {
333
+            throw new ServerNotAvailableException('Lost connection to LDAP server.');
334
+        } else if ($errorCode === 48) {
335
+            throw new \Exception('LDAP authentication method rejected', $errorCode);
336
+        } else if ($errorCode === 1) {
337
+            throw new \Exception('LDAP Operations error', $errorCode);
338
+        } else if ($errorCode === 19) {
339
+            ldap_get_option($this->curArgs[0], LDAP_OPT_ERROR_STRING, $extended_error);
340
+            throw new ConstraintViolationException(!empty($extended_error)?$extended_error:$errorMsg, $errorCode);
341
+        } else {
342
+            \OCP\Util::writeLog('user_ldap',
343
+                'LDAP error '.$errorMsg.' (' .
344
+                $errorCode.') after calling '.
345
+                $this->curFunc,
346
+                \OCP\Util::DEBUG);
347
+        }
348
+    }
349
+
350
+    /**
351
+     * Called after an ldap method is run to act on LDAP error if necessary
352
+     */
353
+    private function postFunctionCall() {
354
+        if($this->isResource($this->curArgs[0])) {
355
+            $resource = $this->curArgs[0];
356
+        } else if(
357
+                $this->curFunc === 'ldap_search'
358
+            && is_array($this->curArgs[0])
359
+            && $this->isResource($this->curArgs[0][0])
360
+        ) {
361
+            // we use always the same LDAP connection resource, is enough to
362
+            // take the first one.
363
+            $resource = $this->curArgs[0][0];
364
+        } else {
365
+            return;
366
+        }
367
+
368
+        $this->processLDAPError($resource);
369
+
370
+        $this->curFunc = '';
371
+        $this->curArgs = [];
372
+    }
373 373
 }
Please login to merge, or discard this patch.
Spacing   +16 added lines, -16 removed lines patch added patch discarded remove patch
@@ -52,12 +52,12 @@  discard block
 block discarded – undo
52 52
 	 * @return mixed
53 53
 	 */
54 54
 	public function connect($host, $port) {
55
-		if(strpos($host, '://') === false) {
56
-			$host = 'ldap://' . $host;
55
+		if (strpos($host, '://') === false) {
56
+			$host = 'ldap://'.$host;
57 57
 		}
58
-		if(strpos($host, ':', strpos($host, '://') + 1) === false) {
58
+		if (strpos($host, ':', strpos($host, '://') + 1) === false) {
59 59
 			//ldap_connect ignores port parameter when URLs are passed
60
-			$host .= ':' . $port;
60
+			$host .= ':'.$port;
61 61
 		}
62 62
 		return $this->invokeLDAPMethod('connect', $host);
63 63
 	}
@@ -267,13 +267,13 @@  discard block
 block discarded – undo
267 267
 	 * @return bool
268 268
 	 */
269 269
 	protected function isResultFalse($result) {
270
-		if($result === false) {
270
+		if ($result === false) {
271 271
 			return true;
272 272
 		}
273 273
 
274
-		if($this->curFunc === 'ldap_search' && is_array($result)) {
274
+		if ($this->curFunc === 'ldap_search' && is_array($result)) {
275 275
 			foreach ($result as $singleResult) {
276
-				if($singleResult === false) {
276
+				if ($singleResult === false) {
277 277
 					return true;
278 278
 				}
279 279
 			}
@@ -287,8 +287,8 @@  discard block
 block discarded – undo
287 287
 	 */
288 288
 	protected function invokeLDAPMethod() {
289 289
 		$arguments = func_get_args();
290
-		$func = 'ldap_' . array_shift($arguments);
291
-		if(function_exists($func)) {
290
+		$func = 'ldap_'.array_shift($arguments);
291
+		if (function_exists($func)) {
292 292
 			$this->preFunctionCall($func, $arguments);
293 293
 			$result = call_user_func_array($func, $arguments);
294 294
 			if ($this->isResultFalse($result)) {
@@ -318,12 +318,12 @@  discard block
 block discarded – undo
318 318
 	 */
319 319
 	private function processLDAPError($resource) {
320 320
 		$errorCode = ldap_errno($resource);
321
-		if($errorCode === 0) {
321
+		if ($errorCode === 0) {
322 322
 			return;
323 323
 		}
324
-		$errorMsg  = ldap_error($resource);
324
+		$errorMsg = ldap_error($resource);
325 325
 
326
-		if($this->curFunc === 'ldap_get_entries'
326
+		if ($this->curFunc === 'ldap_get_entries'
327 327
 			&& $errorCode === -4) {
328 328
 		} else if ($errorCode === 32) {
329 329
 			//for now
@@ -337,10 +337,10 @@  discard block
 block discarded – undo
337 337
 			throw new \Exception('LDAP Operations error', $errorCode);
338 338
 		} else if ($errorCode === 19) {
339 339
 			ldap_get_option($this->curArgs[0], LDAP_OPT_ERROR_STRING, $extended_error);
340
-			throw new ConstraintViolationException(!empty($extended_error)?$extended_error:$errorMsg, $errorCode);
340
+			throw new ConstraintViolationException(!empty($extended_error) ? $extended_error : $errorMsg, $errorCode);
341 341
 		} else {
342 342
 			\OCP\Util::writeLog('user_ldap',
343
-				'LDAP error '.$errorMsg.' (' .
343
+				'LDAP error '.$errorMsg.' ('.
344 344
 				$errorCode.') after calling '.
345 345
 				$this->curFunc,
346 346
 				\OCP\Util::DEBUG);
@@ -351,9 +351,9 @@  discard block
 block discarded – undo
351 351
 	 * Called after an ldap method is run to act on LDAP error if necessary
352 352
 	 */
353 353
 	private function postFunctionCall() {
354
-		if($this->isResource($this->curArgs[0])) {
354
+		if ($this->isResource($this->curArgs[0])) {
355 355
 			$resource = $this->curArgs[0];
356
-		} else if(
356
+		} else if (
357 357
 			   $this->curFunc === 'ldap_search'
358 358
 			&& is_array($this->curArgs[0])
359 359
 			&& $this->isResource($this->curArgs[0][0])
Please login to merge, or discard this patch.
apps/user_ldap/lib/User/DeletedUsersIndex.php 2 patches
Indentation   +70 added lines, -70 removed lines patch added patch discarded remove patch
@@ -31,84 +31,84 @@
 block discarded – undo
31 31
  * @package OCA\User_LDAP
32 32
  */
33 33
 class DeletedUsersIndex {
34
-	/**
35
-	 * @var \OCP\IConfig $config
36
-	 */
37
-	protected $config;
34
+    /**
35
+     * @var \OCP\IConfig $config
36
+     */
37
+    protected $config;
38 38
 
39
-	/**
40
-	 * @var \OCP\IDBConnection $db
41
-	 */
42
-	protected $db;
39
+    /**
40
+     * @var \OCP\IDBConnection $db
41
+     */
42
+    protected $db;
43 43
 
44
-	/**
45
-	 * @var \OCA\User_LDAP\Mapping\UserMapping $mapping
46
-	 */
47
-	protected $mapping;
44
+    /**
45
+     * @var \OCA\User_LDAP\Mapping\UserMapping $mapping
46
+     */
47
+    protected $mapping;
48 48
 
49
-	/**
50
-	 * @var array $deletedUsers
51
-	 */
52
-	protected $deletedUsers;
49
+    /**
50
+     * @var array $deletedUsers
51
+     */
52
+    protected $deletedUsers;
53 53
 
54
-	/**
55
-	 * @param \OCP\IConfig $config
56
-	 * @param \OCP\IDBConnection $db
57
-	 * @param \OCA\User_LDAP\Mapping\UserMapping $mapping
58
-	 */
59
-	public function __construct(\OCP\IConfig $config, \OCP\IDBConnection $db, UserMapping $mapping) {
60
-		$this->config = $config;
61
-		$this->db = $db;
62
-		$this->mapping = $mapping;
63
-	}
54
+    /**
55
+     * @param \OCP\IConfig $config
56
+     * @param \OCP\IDBConnection $db
57
+     * @param \OCA\User_LDAP\Mapping\UserMapping $mapping
58
+     */
59
+    public function __construct(\OCP\IConfig $config, \OCP\IDBConnection $db, UserMapping $mapping) {
60
+        $this->config = $config;
61
+        $this->db = $db;
62
+        $this->mapping = $mapping;
63
+    }
64 64
 
65
-	/**
66
-	 * reads LDAP users marked as deleted from the database
67
-	 * @return \OCA\User_LDAP\User\OfflineUser[]
68
-	 */
69
-	private function fetchDeletedUsers() {
70
-		$deletedUsers = $this->config->getUsersForUserValue(
71
-			'user_ldap', 'isDeleted', '1');
65
+    /**
66
+     * reads LDAP users marked as deleted from the database
67
+     * @return \OCA\User_LDAP\User\OfflineUser[]
68
+     */
69
+    private function fetchDeletedUsers() {
70
+        $deletedUsers = $this->config->getUsersForUserValue(
71
+            'user_ldap', 'isDeleted', '1');
72 72
 
73
-		$userObjects = array();
74
-		foreach($deletedUsers as $user) {
75
-			$userObjects[] = new OfflineUser($user, $this->config, $this->db, $this->mapping);
76
-		}
77
-		$this->deletedUsers = $userObjects;
73
+        $userObjects = array();
74
+        foreach($deletedUsers as $user) {
75
+            $userObjects[] = new OfflineUser($user, $this->config, $this->db, $this->mapping);
76
+        }
77
+        $this->deletedUsers = $userObjects;
78 78
 
79
-		return $this->deletedUsers;
80
-	}
79
+        return $this->deletedUsers;
80
+    }
81 81
 
82
-	/**
83
-	 * returns all LDAP users that are marked as deleted
84
-	 * @return \OCA\User_LDAP\User\OfflineUser[]
85
-	 */
86
-	public function getUsers() {
87
-		if(is_array($this->deletedUsers)) {
88
-			return $this->deletedUsers;
89
-		}
90
-		return $this->fetchDeletedUsers();
91
-	}
82
+    /**
83
+     * returns all LDAP users that are marked as deleted
84
+     * @return \OCA\User_LDAP\User\OfflineUser[]
85
+     */
86
+    public function getUsers() {
87
+        if(is_array($this->deletedUsers)) {
88
+            return $this->deletedUsers;
89
+        }
90
+        return $this->fetchDeletedUsers();
91
+    }
92 92
 
93
-	/**
94
-	 * whether at least one user was detected as deleted
95
-	 * @return bool
96
-	 */
97
-	public function hasUsers() {
98
-		if($this->deletedUsers === false) {
99
-			$this->fetchDeletedUsers();
100
-		}
101
-		if(is_array($this->deletedUsers) && count($this->deletedUsers) > 0) {
102
-			return true;
103
-		}
104
-		return false;
105
-	}
93
+    /**
94
+     * whether at least one user was detected as deleted
95
+     * @return bool
96
+     */
97
+    public function hasUsers() {
98
+        if($this->deletedUsers === false) {
99
+            $this->fetchDeletedUsers();
100
+        }
101
+        if(is_array($this->deletedUsers) && count($this->deletedUsers) > 0) {
102
+            return true;
103
+        }
104
+        return false;
105
+    }
106 106
 
107
-	/**
108
-	 * marks a user as deleted
109
-	 * @param string $ocName
110
-	 */
111
-	public function markUser($ocName) {
112
-		$this->config->setUserValue($ocName, 'user_ldap', 'isDeleted', '1');
113
-	}
107
+    /**
108
+     * marks a user as deleted
109
+     * @param string $ocName
110
+     */
111
+    public function markUser($ocName) {
112
+        $this->config->setUserValue($ocName, 'user_ldap', 'isDeleted', '1');
113
+    }
114 114
 }
Please login to merge, or discard this patch.
Spacing   +4 added lines, -4 removed lines patch added patch discarded remove patch
@@ -71,7 +71,7 @@  discard block
 block discarded – undo
71 71
 			'user_ldap', 'isDeleted', '1');
72 72
 
73 73
 		$userObjects = array();
74
-		foreach($deletedUsers as $user) {
74
+		foreach ($deletedUsers as $user) {
75 75
 			$userObjects[] = new OfflineUser($user, $this->config, $this->db, $this->mapping);
76 76
 		}
77 77
 		$this->deletedUsers = $userObjects;
@@ -84,7 +84,7 @@  discard block
 block discarded – undo
84 84
 	 * @return \OCA\User_LDAP\User\OfflineUser[]
85 85
 	 */
86 86
 	public function getUsers() {
87
-		if(is_array($this->deletedUsers)) {
87
+		if (is_array($this->deletedUsers)) {
88 88
 			return $this->deletedUsers;
89 89
 		}
90 90
 		return $this->fetchDeletedUsers();
@@ -95,10 +95,10 @@  discard block
 block discarded – undo
95 95
 	 * @return bool
96 96
 	 */
97 97
 	public function hasUsers() {
98
-		if($this->deletedUsers === false) {
98
+		if ($this->deletedUsers === false) {
99 99
 			$this->fetchDeletedUsers();
100 100
 		}
101
-		if(is_array($this->deletedUsers) && count($this->deletedUsers) > 0) {
101
+		if (is_array($this->deletedUsers) && count($this->deletedUsers) > 0) {
102 102
 			return true;
103 103
 		}
104 104
 		return false;
Please login to merge, or discard this patch.
apps/user_ldap/lib/User/IUserTools.php 1 patch
Indentation   +5 added lines, -5 removed lines patch added patch discarded remove patch
@@ -30,13 +30,13 @@
 block discarded – undo
30 30
  * defines methods that are required by User class for LDAP interaction
31 31
  */
32 32
 interface IUserTools {
33
-	public function getConnection();
33
+    public function getConnection();
34 34
 
35
-	public function readAttribute($dn, $attr, $filter = 'objectClass=*');
35
+    public function readAttribute($dn, $attr, $filter = 'objectClass=*');
36 36
 
37
-	public function stringResemblesDN($string);
37
+    public function stringResemblesDN($string);
38 38
 
39
-	public function dn2username($dn, $ldapname = null);
39
+    public function dn2username($dn, $ldapname = null);
40 40
 
41
-	public function username2dn($name);
41
+    public function username2dn($name);
42 42
 }
Please login to merge, or discard this patch.
apps/user_ldap/lib/User/Manager.php 2 patches
Spacing   +11 added lines, -11 removed lines patch added patch discarded remove patch
@@ -130,7 +130,7 @@  discard block
 block discarded – undo
130 130
 	 * @return null
131 131
 	 */
132 132
 	private function checkAccess() {
133
-		if(is_null($this->access)) {
133
+		if (is_null($this->access)) {
134 134
 			throw new \Exception('LDAP Access instance must be set first');
135 135
 		}
136 136
 	}
@@ -150,18 +150,18 @@  discard block
 block discarded – undo
150 150
 			$this->access->getConnection()->ldapUserDisplayName,
151 151
 			$this->access->getConnection()->ldapUserDisplayName2,
152 152
 		);
153
-		foreach($possible as $attr) {
154
-			if(!is_null($attr)) {
153
+		foreach ($possible as $attr) {
154
+			if (!is_null($attr)) {
155 155
 				$attributes[] = $attr;
156 156
 			}
157 157
 		}
158 158
 
159 159
 		$homeRule = $this->access->getConnection()->homeFolderNamingRule;
160
-		if(strpos($homeRule, 'attr:') === 0) {
160
+		if (strpos($homeRule, 'attr:') === 0) {
161 161
 			$attributes[] = substr($homeRule, strlen('attr:'));
162 162
 		}
163 163
 
164
-		if(!$minimal) {
164
+		if (!$minimal) {
165 165
 			// attributes that are not really important but may come with big
166 166
 			// payload.
167 167
 			$attributes = array_merge($attributes, array(
@@ -204,11 +204,11 @@  discard block
 block discarded – undo
204 204
 	 */
205 205
 	protected function createInstancyByUserName($id) {
206 206
 		//most likely a uid. Check whether it is a deleted user
207
-		if($this->isDeletedUser($id)) {
207
+		if ($this->isDeletedUser($id)) {
208 208
 			return $this->getDeletedUser($id);
209 209
 		}
210 210
 		$dn = $this->access->username2dn($id);
211
-		if($dn !== false) {
211
+		if ($dn !== false) {
212 212
 			return $this->createAndCache($dn, $id);
213 213
 		}
214 214
 		return null;
@@ -222,15 +222,15 @@  discard block
 block discarded – undo
222 222
 	 */
223 223
 	public function get($id) {
224 224
 		$this->checkAccess();
225
-		if(isset($this->usersByDN[$id])) {
225
+		if (isset($this->usersByDN[$id])) {
226 226
 			return $this->usersByDN[$id];
227
-		} else if(isset($this->usersByUid[$id])) {
227
+		} else if (isset($this->usersByUid[$id])) {
228 228
 			return $this->usersByUid[$id];
229 229
 		}
230 230
 
231
-		if($this->access->stringResemblesDN($id) ) {
231
+		if ($this->access->stringResemblesDN($id)) {
232 232
 			$uid = $this->access->dn2username($id);
233
-			if($uid !== false) {
233
+			if ($uid !== false) {
234 234
 				return $this->createAndCache($id, $uid);
235 235
 			}
236 236
 		}
Please login to merge, or discard this patch.
Indentation   +204 added lines, -204 removed lines patch added patch discarded remove patch
@@ -43,209 +43,209 @@
 block discarded – undo
43 43
  * cache
44 44
  */
45 45
 class Manager {
46
-	/** @var IUserTools */
47
-	protected $access;
48
-
49
-	/** @var IConfig */
50
-	protected $ocConfig;
51
-
52
-	/** @var IDBConnection */
53
-	protected $db;
54
-
55
-	/** @var IUserManager */
56
-	protected $userManager;
57
-
58
-	/** @var INotificationManager */
59
-	protected $notificationManager;
60
-
61
-	/** @var FilesystemHelper */
62
-	protected $ocFilesystem;
63
-
64
-	/** @var LogWrapper */
65
-	protected $ocLog;
66
-
67
-	/** @var Image */
68
-	protected $image;
69
-
70
-	/** @param \OCP\IAvatarManager */
71
-	protected $avatarManager;
72
-
73
-	/**
74
-	 * @var CappedMemoryCache $usersByDN
75
-	 */
76
-	protected $usersByDN;
77
-	/**
78
-	 * @var CappedMemoryCache $usersByUid
79
-	 */
80
-	protected $usersByUid;
81
-
82
-	/**
83
-	 * @param IConfig $ocConfig
84
-	 * @param \OCA\User_LDAP\FilesystemHelper $ocFilesystem object that
85
-	 * gives access to necessary functions from the OC filesystem
86
-	 * @param  \OCA\User_LDAP\LogWrapper $ocLog
87
-	 * @param IAvatarManager $avatarManager
88
-	 * @param Image $image an empty image instance
89
-	 * @param IDBConnection $db
90
-	 * @throws \Exception when the methods mentioned above do not exist
91
-	 */
92
-	public function __construct(IConfig $ocConfig,
93
-								FilesystemHelper $ocFilesystem, LogWrapper $ocLog,
94
-								IAvatarManager $avatarManager, Image $image,
95
-								IDBConnection $db, IUserManager $userManager,
96
-								INotificationManager $notificationManager) {
97
-
98
-		$this->ocConfig            = $ocConfig;
99
-		$this->ocFilesystem        = $ocFilesystem;
100
-		$this->ocLog               = $ocLog;
101
-		$this->avatarManager       = $avatarManager;
102
-		$this->image               = $image;
103
-		$this->db                  = $db;
104
-		$this->userManager         = $userManager;
105
-		$this->notificationManager = $notificationManager;
106
-		$this->usersByDN           = new CappedMemoryCache();
107
-		$this->usersByUid          = new CappedMemoryCache();
108
-	}
109
-
110
-	/**
111
-	 * @brief binds manager to an instance of IUserTools (implemented by
112
-	 * Access). It needs to be assigned first before the manager can be used.
113
-	 * @param IUserTools
114
-	 */
115
-	public function setLdapAccess(IUserTools $access) {
116
-		$this->access = $access;
117
-	}
118
-
119
-	/**
120
-	 * @brief creates an instance of User and caches (just runtime) it in the
121
-	 * property array
122
-	 * @param string $dn the DN of the user
123
-	 * @param string $uid the internal (owncloud) username
124
-	 * @return \OCA\User_LDAP\User\User
125
-	 */
126
-	private function createAndCache($dn, $uid) {
127
-		$this->checkAccess();
128
-		$user = new User($uid, $dn, $this->access, $this->ocConfig,
129
-			$this->ocFilesystem, clone $this->image, $this->ocLog,
130
-			$this->avatarManager, $this->userManager, 
131
-			$this->notificationManager);
132
-		$this->usersByDN[$dn]   = $user;
133
-		$this->usersByUid[$uid] = $user;
134
-		return $user;
135
-	}
136
-
137
-	/**
138
-	 * @brief checks whether the Access instance has been set
139
-	 * @throws \Exception if Access has not been set
140
-	 * @return null
141
-	 */
142
-	private function checkAccess() {
143
-		if(is_null($this->access)) {
144
-			throw new \Exception('LDAP Access instance must be set first');
145
-		}
146
-	}
147
-
148
-	/**
149
-	 * returns a list of attributes that will be processed further, e.g. quota,
150
-	 * email, displayname, or others.
151
-	 * @param bool $minimal - optional, set to true to skip attributes with big
152
-	 * payload
153
-	 * @return string[]
154
-	 */
155
-	public function getAttributes($minimal = false) {
156
-		$attributes = array('dn', 'uid', 'samaccountname', 'memberof');
157
-		$possible = array(
158
-			$this->access->getConnection()->ldapQuotaAttribute,
159
-			$this->access->getConnection()->ldapEmailAttribute,
160
-			$this->access->getConnection()->ldapUserDisplayName,
161
-			$this->access->getConnection()->ldapUserDisplayName2,
162
-		);
163
-		foreach($possible as $attr) {
164
-			if(!is_null($attr)) {
165
-				$attributes[] = $attr;
166
-			}
167
-		}
168
-
169
-		$homeRule = $this->access->getConnection()->homeFolderNamingRule;
170
-		if(strpos($homeRule, 'attr:') === 0) {
171
-			$attributes[] = substr($homeRule, strlen('attr:'));
172
-		}
173
-
174
-		if(!$minimal) {
175
-			// attributes that are not really important but may come with big
176
-			// payload.
177
-			$attributes = array_merge($attributes, array(
178
-				'jpegphoto',
179
-				'thumbnailphoto'
180
-			));
181
-		}
182
-
183
-		return $attributes;
184
-	}
185
-
186
-	/**
187
-	 * Checks whether the specified user is marked as deleted
188
-	 * @param string $id the Nextcloud user name
189
-	 * @return bool
190
-	 */
191
-	public function isDeletedUser($id) {
192
-		$isDeleted = $this->ocConfig->getUserValue(
193
-			$id, 'user_ldap', 'isDeleted', 0);
194
-		return intval($isDeleted) === 1;
195
-	}
196
-
197
-	/**
198
-	 * creates and returns an instance of OfflineUser for the specified user
199
-	 * @param string $id
200
-	 * @return \OCA\User_LDAP\User\OfflineUser
201
-	 */
202
-	public function getDeletedUser($id) {
203
-		return new OfflineUser(
204
-			$id,
205
-			$this->ocConfig,
206
-			$this->db,
207
-			$this->access->getUserMapper());
208
-	}
209
-
210
-	/**
211
-	 * @brief returns a User object by it's Nextcloud username
212
-	 * @param string $id the DN or username of the user
213
-	 * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
214
-	 */
215
-	protected function createInstancyByUserName($id) {
216
-		//most likely a uid. Check whether it is a deleted user
217
-		if($this->isDeletedUser($id)) {
218
-			return $this->getDeletedUser($id);
219
-		}
220
-		$dn = $this->access->username2dn($id);
221
-		if($dn !== false) {
222
-			return $this->createAndCache($dn, $id);
223
-		}
224
-		return null;
225
-	}
226
-
227
-	/**
228
-	 * @brief returns a User object by it's DN or Nextcloud username
229
-	 * @param string $id the DN or username of the user
230
-	 * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
231
-	 * @throws \Exception when connection could not be established
232
-	 */
233
-	public function get($id) {
234
-		$this->checkAccess();
235
-		if(isset($this->usersByDN[$id])) {
236
-			return $this->usersByDN[$id];
237
-		} else if(isset($this->usersByUid[$id])) {
238
-			return $this->usersByUid[$id];
239
-		}
240
-
241
-		if($this->access->stringResemblesDN($id) ) {
242
-			$uid = $this->access->dn2username($id);
243
-			if($uid !== false) {
244
-				return $this->createAndCache($id, $uid);
245
-			}
246
-		}
247
-
248
-		return $this->createInstancyByUserName($id);
249
-	}
46
+    /** @var IUserTools */
47
+    protected $access;
48
+
49
+    /** @var IConfig */
50
+    protected $ocConfig;
51
+
52
+    /** @var IDBConnection */
53
+    protected $db;
54
+
55
+    /** @var IUserManager */
56
+    protected $userManager;
57
+
58
+    /** @var INotificationManager */
59
+    protected $notificationManager;
60
+
61
+    /** @var FilesystemHelper */
62
+    protected $ocFilesystem;
63
+
64
+    /** @var LogWrapper */
65
+    protected $ocLog;
66
+
67
+    /** @var Image */
68
+    protected $image;
69
+
70
+    /** @param \OCP\IAvatarManager */
71
+    protected $avatarManager;
72
+
73
+    /**
74
+     * @var CappedMemoryCache $usersByDN
75
+     */
76
+    protected $usersByDN;
77
+    /**
78
+     * @var CappedMemoryCache $usersByUid
79
+     */
80
+    protected $usersByUid;
81
+
82
+    /**
83
+     * @param IConfig $ocConfig
84
+     * @param \OCA\User_LDAP\FilesystemHelper $ocFilesystem object that
85
+     * gives access to necessary functions from the OC filesystem
86
+     * @param  \OCA\User_LDAP\LogWrapper $ocLog
87
+     * @param IAvatarManager $avatarManager
88
+     * @param Image $image an empty image instance
89
+     * @param IDBConnection $db
90
+     * @throws \Exception when the methods mentioned above do not exist
91
+     */
92
+    public function __construct(IConfig $ocConfig,
93
+                                FilesystemHelper $ocFilesystem, LogWrapper $ocLog,
94
+                                IAvatarManager $avatarManager, Image $image,
95
+                                IDBConnection $db, IUserManager $userManager,
96
+                                INotificationManager $notificationManager) {
97
+
98
+        $this->ocConfig            = $ocConfig;
99
+        $this->ocFilesystem        = $ocFilesystem;
100
+        $this->ocLog               = $ocLog;
101
+        $this->avatarManager       = $avatarManager;
102
+        $this->image               = $image;
103
+        $this->db                  = $db;
104
+        $this->userManager         = $userManager;
105
+        $this->notificationManager = $notificationManager;
106
+        $this->usersByDN           = new CappedMemoryCache();
107
+        $this->usersByUid          = new CappedMemoryCache();
108
+    }
109
+
110
+    /**
111
+     * @brief binds manager to an instance of IUserTools (implemented by
112
+     * Access). It needs to be assigned first before the manager can be used.
113
+     * @param IUserTools
114
+     */
115
+    public function setLdapAccess(IUserTools $access) {
116
+        $this->access = $access;
117
+    }
118
+
119
+    /**
120
+     * @brief creates an instance of User and caches (just runtime) it in the
121
+     * property array
122
+     * @param string $dn the DN of the user
123
+     * @param string $uid the internal (owncloud) username
124
+     * @return \OCA\User_LDAP\User\User
125
+     */
126
+    private function createAndCache($dn, $uid) {
127
+        $this->checkAccess();
128
+        $user = new User($uid, $dn, $this->access, $this->ocConfig,
129
+            $this->ocFilesystem, clone $this->image, $this->ocLog,
130
+            $this->avatarManager, $this->userManager, 
131
+            $this->notificationManager);
132
+        $this->usersByDN[$dn]   = $user;
133
+        $this->usersByUid[$uid] = $user;
134
+        return $user;
135
+    }
136
+
137
+    /**
138
+     * @brief checks whether the Access instance has been set
139
+     * @throws \Exception if Access has not been set
140
+     * @return null
141
+     */
142
+    private function checkAccess() {
143
+        if(is_null($this->access)) {
144
+            throw new \Exception('LDAP Access instance must be set first');
145
+        }
146
+    }
147
+
148
+    /**
149
+     * returns a list of attributes that will be processed further, e.g. quota,
150
+     * email, displayname, or others.
151
+     * @param bool $minimal - optional, set to true to skip attributes with big
152
+     * payload
153
+     * @return string[]
154
+     */
155
+    public function getAttributes($minimal = false) {
156
+        $attributes = array('dn', 'uid', 'samaccountname', 'memberof');
157
+        $possible = array(
158
+            $this->access->getConnection()->ldapQuotaAttribute,
159
+            $this->access->getConnection()->ldapEmailAttribute,
160
+            $this->access->getConnection()->ldapUserDisplayName,
161
+            $this->access->getConnection()->ldapUserDisplayName2,
162
+        );
163
+        foreach($possible as $attr) {
164
+            if(!is_null($attr)) {
165
+                $attributes[] = $attr;
166
+            }
167
+        }
168
+
169
+        $homeRule = $this->access->getConnection()->homeFolderNamingRule;
170
+        if(strpos($homeRule, 'attr:') === 0) {
171
+            $attributes[] = substr($homeRule, strlen('attr:'));
172
+        }
173
+
174
+        if(!$minimal) {
175
+            // attributes that are not really important but may come with big
176
+            // payload.
177
+            $attributes = array_merge($attributes, array(
178
+                'jpegphoto',
179
+                'thumbnailphoto'
180
+            ));
181
+        }
182
+
183
+        return $attributes;
184
+    }
185
+
186
+    /**
187
+     * Checks whether the specified user is marked as deleted
188
+     * @param string $id the Nextcloud user name
189
+     * @return bool
190
+     */
191
+    public function isDeletedUser($id) {
192
+        $isDeleted = $this->ocConfig->getUserValue(
193
+            $id, 'user_ldap', 'isDeleted', 0);
194
+        return intval($isDeleted) === 1;
195
+    }
196
+
197
+    /**
198
+     * creates and returns an instance of OfflineUser for the specified user
199
+     * @param string $id
200
+     * @return \OCA\User_LDAP\User\OfflineUser
201
+     */
202
+    public function getDeletedUser($id) {
203
+        return new OfflineUser(
204
+            $id,
205
+            $this->ocConfig,
206
+            $this->db,
207
+            $this->access->getUserMapper());
208
+    }
209
+
210
+    /**
211
+     * @brief returns a User object by it's Nextcloud username
212
+     * @param string $id the DN or username of the user
213
+     * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
214
+     */
215
+    protected function createInstancyByUserName($id) {
216
+        //most likely a uid. Check whether it is a deleted user
217
+        if($this->isDeletedUser($id)) {
218
+            return $this->getDeletedUser($id);
219
+        }
220
+        $dn = $this->access->username2dn($id);
221
+        if($dn !== false) {
222
+            return $this->createAndCache($dn, $id);
223
+        }
224
+        return null;
225
+    }
226
+
227
+    /**
228
+     * @brief returns a User object by it's DN or Nextcloud username
229
+     * @param string $id the DN or username of the user
230
+     * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
231
+     * @throws \Exception when connection could not be established
232
+     */
233
+    public function get($id) {
234
+        $this->checkAccess();
235
+        if(isset($this->usersByDN[$id])) {
236
+            return $this->usersByDN[$id];
237
+        } else if(isset($this->usersByUid[$id])) {
238
+            return $this->usersByUid[$id];
239
+        }
240
+
241
+        if($this->access->stringResemblesDN($id) ) {
242
+            $uid = $this->access->dn2username($id);
243
+            if($uid !== false) {
244
+                return $this->createAndCache($id, $uid);
245
+            }
246
+        }
247
+
248
+        return $this->createInstancyByUserName($id);
249
+    }
250 250
 
251 251
 }
Please login to merge, or discard this patch.
apps/user_ldap/lib/User/OfflineUser.php 2 patches
Spacing   +4 added lines, -4 removed lines patch added patch discarded remove patch
@@ -179,14 +179,14 @@  discard block
 block discarded – undo
179 179
 	 * reads the user details
180 180
 	 */
181 181
 	protected function fetchDetails() {
182
-		$properties = array (
182
+		$properties = array(
183 183
 			'displayName' => 'user_ldap',
184 184
 			'uid'         => 'user_ldap',
185 185
 			'homePath'    => 'user_ldap',
186 186
 			'email'       => 'settings',
187 187
 			'lastLogin'   => 'login'
188 188
 		);
189
-		foreach($properties as $property => $app) {
189
+		foreach ($properties as $property => $app) {
190 190
 			$this->$property = $this->config->getUserValue($this->ocName, $app, $property, '');
191 191
 		}
192 192
 
@@ -209,7 +209,7 @@  discard block
 block discarded – undo
209 209
 		', 1);
210 210
 		$query->execute(array($this->ocName));
211 211
 		$sResult = $query->fetchColumn(0);
212
-		if(intval($sResult) === 1) {
212
+		if (intval($sResult) === 1) {
213 213
 			$this->hasActiveShares = true;
214 214
 			return;
215 215
 		}
@@ -221,7 +221,7 @@  discard block
 block discarded – undo
221 221
 		', 1);
222 222
 		$query->execute(array($this->ocName));
223 223
 		$sResult = $query->fetchColumn(0);
224
-		if(intval($sResult) === 1) {
224
+		if (intval($sResult) === 1) {
225 225
 			$this->hasActiveShares = true;
226 226
 			return;
227 227
 		}
Please login to merge, or discard this patch.
Indentation   +193 added lines, -193 removed lines patch added patch discarded remove patch
@@ -27,205 +27,205 @@
 block discarded – undo
27 27
 use OCA\User_LDAP\Mapping\UserMapping;
28 28
 
29 29
 class OfflineUser {
30
-	/**
31
-	 * @var string $ocName
32
-	 */
33
-	protected $ocName;
34
-	/**
35
-	 * @var string $dn
36
-	 */
37
-	protected $dn;
38
-	/**
39
-	 * @var string $uid the UID as provided by LDAP
40
-	 */
41
-	protected $uid;
42
-	/**
43
-	 * @var string $displayName
44
-	 */
45
-	protected $displayName;
46
-	/**
47
-	 * @var string $homePath
48
-	 */
49
-	protected $homePath;
50
-	/**
51
-	 * @var string $lastLogin the timestamp of the last login
52
-	 */
53
-	protected $lastLogin;
54
-	/**
55
-	 * @var string $email
56
-	 */
57
-	protected $email;
58
-	/**
59
-	 * @var bool $hasActiveShares
60
-	 */
61
-	protected $hasActiveShares;
62
-	/**
63
-	 * @var \OCP\IConfig $config
64
-	 */
65
-	protected $config;
66
-	/**
67
-	 * @var \OCP\IDBConnection $db
68
-	 */
69
-	protected $db;
70
-	/**
71
-	 * @var \OCA\User_LDAP\Mapping\UserMapping
72
-	 */
73
-	protected $mapping;
74
-
75
-	/**
76
-	 * @param string $ocName
77
-	 * @param \OCP\IConfig $config
78
-	 * @param \OCP\IDBConnection $db
79
-	 * @param \OCA\User_LDAP\Mapping\UserMapping $mapping
80
-	 */
81
-	public function __construct($ocName, \OCP\IConfig $config, \OCP\IDBConnection $db, UserMapping $mapping) {
82
-		$this->ocName = $ocName;
83
-		$this->config = $config;
84
-		$this->db = $db;
85
-		$this->mapping = $mapping;
86
-		$this->fetchDetails();
87
-	}
88
-
89
-	/**
90
-	 * remove the Delete-flag from the user.
91
-	 */
92
-	public function unmark() {
93
-		$this->config->setUserValue($this->ocName, 'user_ldap', 'isDeleted', '0');
94
-	}
95
-
96
-	/**
97
-	 * exports the user details in an assoc array
98
-	 * @return array
99
-	 */
100
-	public function export() {
101
-		$data = array();
102
-		$data['ocName'] = $this->getOCName();
103
-		$data['dn'] = $this->getDN();
104
-		$data['uid'] = $this->getUID();
105
-		$data['displayName'] = $this->getDisplayName();
106
-		$data['homePath'] = $this->getHomePath();
107
-		$data['lastLogin'] = $this->getLastLogin();
108
-		$data['email'] = $this->getEmail();
109
-		$data['hasActiveShares'] = $this->getHasActiveShares();
110
-
111
-		return $data;
112
-	}
113
-
114
-	/**
115
-	 * getter for Nextcloud internal name
116
-	 * @return string
117
-	 */
118
-	public function getOCName() {
119
-		return $this->ocName;
120
-	}
121
-
122
-	/**
123
-	 * getter for LDAP uid
124
-	 * @return string
125
-	 */
126
-	public function getUID() {
127
-		return $this->uid;
128
-	}
129
-
130
-	/**
131
-	 * getter for LDAP DN
132
-	 * @return string
133
-	 */
134
-	public function getDN() {
135
-		return $this->dn;
136
-	}
137
-
138
-	/**
139
-	 * getter for display name
140
-	 * @return string
141
-	 */
142
-	public function getDisplayName() {
143
-		return $this->displayName;
144
-	}
145
-
146
-	/**
147
-	 * getter for email
148
-	 * @return string
149
-	 */
150
-	public function getEmail() {
151
-		return $this->email;
152
-	}
153
-
154
-	/**
155
-	 * getter for home directory path
156
-	 * @return string
157
-	 */
158
-	public function getHomePath() {
159
-		return $this->homePath;
160
-	}
161
-
162
-	/**
163
-	 * getter for the last login timestamp
164
-	 * @return int
165
-	 */
166
-	public function getLastLogin() {
167
-		return intval($this->lastLogin);
168
-	}
169
-
170
-	/**
171
-	 * getter for having active shares
172
-	 * @return bool
173
-	 */
174
-	public function getHasActiveShares() {
175
-		return $this->hasActiveShares;
176
-	}
177
-
178
-	/**
179
-	 * reads the user details
180
-	 */
181
-	protected function fetchDetails() {
182
-		$properties = array (
183
-			'displayName' => 'user_ldap',
184
-			'uid'         => 'user_ldap',
185
-			'homePath'    => 'user_ldap',
186
-			'email'       => 'settings',
187
-			'lastLogin'   => 'login'
188
-		);
189
-		foreach($properties as $property => $app) {
190
-			$this->$property = $this->config->getUserValue($this->ocName, $app, $property, '');
191
-		}
192
-
193
-		$dn = $this->mapping->getDNByName($this->ocName);
194
-		$this->dn = ($dn !== false) ? $dn : '';
195
-
196
-		$this->determineShares();
197
-	}
198
-
199
-
200
-	/**
201
-	 * finds out whether the user has active shares. The result is stored in
202
-	 * $this->hasActiveShares
203
-	 */
204
-	protected function determineShares() {
205
-		$query = $this->db->prepare('
30
+    /**
31
+     * @var string $ocName
32
+     */
33
+    protected $ocName;
34
+    /**
35
+     * @var string $dn
36
+     */
37
+    protected $dn;
38
+    /**
39
+     * @var string $uid the UID as provided by LDAP
40
+     */
41
+    protected $uid;
42
+    /**
43
+     * @var string $displayName
44
+     */
45
+    protected $displayName;
46
+    /**
47
+     * @var string $homePath
48
+     */
49
+    protected $homePath;
50
+    /**
51
+     * @var string $lastLogin the timestamp of the last login
52
+     */
53
+    protected $lastLogin;
54
+    /**
55
+     * @var string $email
56
+     */
57
+    protected $email;
58
+    /**
59
+     * @var bool $hasActiveShares
60
+     */
61
+    protected $hasActiveShares;
62
+    /**
63
+     * @var \OCP\IConfig $config
64
+     */
65
+    protected $config;
66
+    /**
67
+     * @var \OCP\IDBConnection $db
68
+     */
69
+    protected $db;
70
+    /**
71
+     * @var \OCA\User_LDAP\Mapping\UserMapping
72
+     */
73
+    protected $mapping;
74
+
75
+    /**
76
+     * @param string $ocName
77
+     * @param \OCP\IConfig $config
78
+     * @param \OCP\IDBConnection $db
79
+     * @param \OCA\User_LDAP\Mapping\UserMapping $mapping
80
+     */
81
+    public function __construct($ocName, \OCP\IConfig $config, \OCP\IDBConnection $db, UserMapping $mapping) {
82
+        $this->ocName = $ocName;
83
+        $this->config = $config;
84
+        $this->db = $db;
85
+        $this->mapping = $mapping;
86
+        $this->fetchDetails();
87
+    }
88
+
89
+    /**
90
+     * remove the Delete-flag from the user.
91
+     */
92
+    public function unmark() {
93
+        $this->config->setUserValue($this->ocName, 'user_ldap', 'isDeleted', '0');
94
+    }
95
+
96
+    /**
97
+     * exports the user details in an assoc array
98
+     * @return array
99
+     */
100
+    public function export() {
101
+        $data = array();
102
+        $data['ocName'] = $this->getOCName();
103
+        $data['dn'] = $this->getDN();
104
+        $data['uid'] = $this->getUID();
105
+        $data['displayName'] = $this->getDisplayName();
106
+        $data['homePath'] = $this->getHomePath();
107
+        $data['lastLogin'] = $this->getLastLogin();
108
+        $data['email'] = $this->getEmail();
109
+        $data['hasActiveShares'] = $this->getHasActiveShares();
110
+
111
+        return $data;
112
+    }
113
+
114
+    /**
115
+     * getter for Nextcloud internal name
116
+     * @return string
117
+     */
118
+    public function getOCName() {
119
+        return $this->ocName;
120
+    }
121
+
122
+    /**
123
+     * getter for LDAP uid
124
+     * @return string
125
+     */
126
+    public function getUID() {
127
+        return $this->uid;
128
+    }
129
+
130
+    /**
131
+     * getter for LDAP DN
132
+     * @return string
133
+     */
134
+    public function getDN() {
135
+        return $this->dn;
136
+    }
137
+
138
+    /**
139
+     * getter for display name
140
+     * @return string
141
+     */
142
+    public function getDisplayName() {
143
+        return $this->displayName;
144
+    }
145
+
146
+    /**
147
+     * getter for email
148
+     * @return string
149
+     */
150
+    public function getEmail() {
151
+        return $this->email;
152
+    }
153
+
154
+    /**
155
+     * getter for home directory path
156
+     * @return string
157
+     */
158
+    public function getHomePath() {
159
+        return $this->homePath;
160
+    }
161
+
162
+    /**
163
+     * getter for the last login timestamp
164
+     * @return int
165
+     */
166
+    public function getLastLogin() {
167
+        return intval($this->lastLogin);
168
+    }
169
+
170
+    /**
171
+     * getter for having active shares
172
+     * @return bool
173
+     */
174
+    public function getHasActiveShares() {
175
+        return $this->hasActiveShares;
176
+    }
177
+
178
+    /**
179
+     * reads the user details
180
+     */
181
+    protected function fetchDetails() {
182
+        $properties = array (
183
+            'displayName' => 'user_ldap',
184
+            'uid'         => 'user_ldap',
185
+            'homePath'    => 'user_ldap',
186
+            'email'       => 'settings',
187
+            'lastLogin'   => 'login'
188
+        );
189
+        foreach($properties as $property => $app) {
190
+            $this->$property = $this->config->getUserValue($this->ocName, $app, $property, '');
191
+        }
192
+
193
+        $dn = $this->mapping->getDNByName($this->ocName);
194
+        $this->dn = ($dn !== false) ? $dn : '';
195
+
196
+        $this->determineShares();
197
+    }
198
+
199
+
200
+    /**
201
+     * finds out whether the user has active shares. The result is stored in
202
+     * $this->hasActiveShares
203
+     */
204
+    protected function determineShares() {
205
+        $query = $this->db->prepare('
206 206
 			SELECT COUNT(`uid_owner`)
207 207
 			FROM `*PREFIX*share`
208 208
 			WHERE `uid_owner` = ?
209 209
 		', 1);
210
-		$query->execute(array($this->ocName));
211
-		$sResult = $query->fetchColumn(0);
212
-		if(intval($sResult) === 1) {
213
-			$this->hasActiveShares = true;
214
-			return;
215
-		}
216
-
217
-		$query = $this->db->prepare('
210
+        $query->execute(array($this->ocName));
211
+        $sResult = $query->fetchColumn(0);
212
+        if(intval($sResult) === 1) {
213
+            $this->hasActiveShares = true;
214
+            return;
215
+        }
216
+
217
+        $query = $this->db->prepare('
218 218
 			SELECT COUNT(`owner`)
219 219
 			FROM `*PREFIX*share_external`
220 220
 			WHERE `owner` = ?
221 221
 		', 1);
222
-		$query->execute(array($this->ocName));
223
-		$sResult = $query->fetchColumn(0);
224
-		if(intval($sResult) === 1) {
225
-			$this->hasActiveShares = true;
226
-			return;
227
-		}
228
-
229
-		$this->hasActiveShares = false;
230
-	}
222
+        $query->execute(array($this->ocName));
223
+        $sResult = $query->fetchColumn(0);
224
+        if(intval($sResult) === 1) {
225
+            $this->hasActiveShares = true;
226
+            return;
227
+        }
228
+
229
+        $this->hasActiveShares = false;
230
+    }
231 231
 }
Please login to merge, or discard this patch.
apps/user_ldap/lib/IUserLDAP.php 1 patch
Indentation   +19 added lines, -19 removed lines patch added patch discarded remove patch
@@ -24,26 +24,26 @@
 block discarded – undo
24 24
 
25 25
 interface IUserLDAP {
26 26
 
27
-	//Functions used by LDAPProvider
27
+    //Functions used by LDAPProvider
28 28
 	
29
-	/**
30
-	 * Return access for LDAP interaction.
31
-	 * @param string $uid
32
-	 * @return Access instance of Access for LDAP interaction
33
-	 */
34
-	public function getLDAPAccess($uid);
29
+    /**
30
+     * Return access for LDAP interaction.
31
+     * @param string $uid
32
+     * @return Access instance of Access for LDAP interaction
33
+     */
34
+    public function getLDAPAccess($uid);
35 35
 	
36
-	/**
37
-	 * Return a new LDAP connection for the specified user.
38
-	 * @param string $uid
39
-	 * @return resource of the LDAP connection
40
-	 */
41
-	public function getNewLDAPConnection($uid);
36
+    /**
37
+     * Return a new LDAP connection for the specified user.
38
+     * @param string $uid
39
+     * @return resource of the LDAP connection
40
+     */
41
+    public function getNewLDAPConnection($uid);
42 42
 
43
-	/**
44
-	 * Return the username for the given LDAP DN, if available.
45
-	 * @param string $dn
46
-	 * @return string|false with the username
47
-	 */
48
-	public function dn2UserName($dn);
43
+    /**
44
+     * Return the username for the given LDAP DN, if available.
45
+     * @param string $dn
46
+     * @return string|false with the username
47
+     */
48
+    public function dn2UserName($dn);
49 49
 }
Please login to merge, or discard this patch.