1
|
|
|
<?php |
2
|
|
|
/** |
3
|
|
|
* @author Björn Schießle <[email protected]> |
4
|
|
|
* @author Joas Schilling <[email protected]> |
5
|
|
|
* @author Morris Jobke <[email protected]> |
6
|
|
|
* @author Robin Appelman <[email protected]> |
7
|
|
|
* @author Roeland Jago Douma <[email protected]> |
8
|
|
|
* @author Thomas Müller <[email protected]> |
9
|
|
|
* @author Vincent Petry <[email protected]> |
10
|
|
|
* |
11
|
|
|
* @copyright Copyright (c) 2015, ownCloud, Inc. |
12
|
|
|
* @license AGPL-3.0 |
13
|
|
|
* |
14
|
|
|
* This code is free software: you can redistribute it and/or modify |
15
|
|
|
* it under the terms of the GNU Affero General Public License, version 3, |
16
|
|
|
* as published by the Free Software Foundation. |
17
|
|
|
* |
18
|
|
|
* This program is distributed in the hope that it will be useful, |
19
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
20
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
21
|
|
|
* GNU Affero General Public License for more details. |
22
|
|
|
* |
23
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3, |
24
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/> |
25
|
|
|
* |
26
|
|
|
*/ |
27
|
|
|
|
28
|
|
|
namespace OCA\Files_Sharing\API; |
29
|
|
|
|
30
|
|
|
use OC\HintException; |
31
|
|
|
|
32
|
|
|
class Local { |
33
|
|
|
|
34
|
|
|
/** |
35
|
|
|
* get all shares |
36
|
|
|
* |
37
|
|
|
* @param array $params option 'file' to limit the result to a specific file/folder |
38
|
|
|
* @return \OC_OCS_Result share information |
39
|
|
|
*/ |
40
|
12 |
|
public static function getAllShares($params) { |
|
|
|
|
41
|
12 |
|
if (isset($_GET['shared_with_me']) && $_GET['shared_with_me'] !== 'false') { |
42
|
1 |
|
return self::getFilesSharedWithMe(); |
43
|
|
|
} |
44
|
|
|
// if a file is specified, get the share for this file |
45
|
11 |
|
if (isset($_GET['path'])) { |
46
|
10 |
|
if ( isset($_GET['reshares']) && $_GET['reshares'] !== 'false' ) { |
47
|
1 |
|
$reshares = true; |
48
|
1 |
|
} else { |
49
|
10 |
|
$reshares = false; |
50
|
|
|
} |
51
|
|
|
|
52
|
10 |
|
if (isset($_GET['subfiles']) && $_GET['subfiles'] !== 'false') { |
53
|
6 |
|
return self::getSharesFromFolder($_GET['path']); |
54
|
|
|
} |
55
|
4 |
|
return self::collectShares(self::getFileId($_GET['path']), |
56
|
4 |
|
self::getItemType($_GET['path']), |
57
|
4 |
|
false, |
58
|
4 |
|
$_GET['path'], |
59
|
4 |
|
$reshares); |
60
|
|
|
} |
61
|
|
|
|
62
|
2 |
|
$shares = \OCP\Share::getItemShared('file', null); |
63
|
|
|
|
64
|
2 |
|
if ($shares === false) { |
65
|
|
|
return new \OC_OCS_Result(null, 404, 'could not get shares'); |
66
|
|
|
} else { |
67
|
2 |
|
foreach ($shares as &$share) { |
68
|
2 |
View Code Duplication |
if ($share['item_type'] === 'file' && isset($share['path'])) { |
|
|
|
|
69
|
1 |
|
$share['mimetype'] = \OC_Helper::getFileNameMimeType($share['path']); |
70
|
1 |
|
if (\OC::$server->getPreviewManager()->isMimeSupported($share['mimetype'])) { |
71
|
1 |
|
$share['isPreviewAvailable'] = true; |
72
|
1 |
|
} |
73
|
1 |
|
} |
74
|
|
|
|
75
|
2 |
View Code Duplication |
if (!is_null($share['token'])) { |
|
|
|
|
76
|
1 |
|
$share['url'] = \OC::$server->getURLGenerator()->linkToRouteAbsolute('files_sharing.sharecontroller.showShare', ['token' => $share['token']]); |
77
|
1 |
|
} |
78
|
2 |
|
} |
79
|
2 |
|
return new \OC_OCS_Result($shares); |
80
|
|
|
} |
81
|
|
|
|
82
|
|
|
} |
83
|
|
|
|
84
|
|
|
/** |
85
|
|
|
* get share information for a given share |
86
|
|
|
* |
87
|
|
|
* @param array $params which contains a 'id' |
88
|
|
|
* @return \OC_OCS_Result share information |
89
|
|
|
*/ |
90
|
3 |
|
public static function getShare($params) { |
91
|
|
|
|
92
|
3 |
|
$s = self::getShareFromId($params['id']); |
93
|
|
|
|
94
|
3 |
|
return self::collectShares($s['file_source'], $s['item_type'], true, null, false, (int)$params['id']); |
95
|
|
|
} |
96
|
|
|
|
97
|
|
|
/** |
98
|
|
|
* collect all share information, either of a specific share or all |
99
|
|
|
* shares for a given path |
100
|
|
|
* |
101
|
|
|
* @param string $itemSource |
102
|
|
|
* @param string $itemType |
103
|
|
|
* @param bool $getSpecificShare |
104
|
|
|
* @param string $path |
105
|
|
|
* @param bool $reshares |
106
|
|
|
* @param int $id |
107
|
|
|
* |
108
|
|
|
* @return \OC_OCS_Result |
109
|
|
|
*/ |
110
|
6 |
|
private static function collectShares($itemSource, $itemType, $getSpecificShare = false, $path = null, $reshares = false, $id = null) { |
111
|
6 |
|
if ($itemSource !== null) { |
112
|
5 |
|
$shares = \OCP\Share::getItemShared($itemType, $itemSource); |
113
|
5 |
|
$receivedFrom = \OCP\Share::getItemSharedWithBySource($itemType, $itemSource); |
114
|
|
|
// if a specific share was specified only return this one |
115
|
5 |
|
if ($getSpecificShare === true) { |
116
|
2 |
|
foreach ($shares as $share) { |
117
|
2 |
|
if ($share['id'] === $id) { |
118
|
2 |
|
$shares = array('element' => $share); |
119
|
2 |
|
break; |
120
|
|
|
} |
121
|
2 |
|
} |
122
|
2 |
|
} else { |
123
|
4 |
|
foreach ($shares as $key => $share) { |
124
|
4 |
|
$shares[$key]['path'] = $path; |
125
|
4 |
|
} |
126
|
|
|
} |
127
|
|
|
|
128
|
|
|
|
129
|
|
|
// include also reshares in the lists. This means that the result |
130
|
|
|
// will contain every user with access to the file. |
131
|
5 |
|
if ($reshares === true) { |
132
|
1 |
|
$shares = self::addReshares($shares, $itemSource); |
133
|
1 |
|
} |
134
|
|
|
|
135
|
5 |
|
if ($receivedFrom) { |
|
|
|
|
136
|
1 |
|
foreach ($shares as $key => $share) { |
137
|
1 |
|
$shares[$key]['received_from'] = $receivedFrom['uid_owner']; |
138
|
1 |
|
$shares[$key]['received_from_displayname'] = \OCP\User::getDisplayName($receivedFrom['uid_owner']); |
139
|
1 |
|
} |
140
|
1 |
|
} |
141
|
5 |
|
} else { |
142
|
1 |
|
$shares = null; |
143
|
|
|
} |
144
|
|
|
|
145
|
6 |
|
if ($shares === null || empty($shares)) { |
146
|
1 |
|
return new \OC_OCS_Result(null, 404, 'share doesn\'t exist'); |
147
|
|
|
} else { |
148
|
5 |
|
foreach ($shares as &$share) { |
149
|
5 |
View Code Duplication |
if (!is_null($share['token'])) { |
|
|
|
|
150
|
3 |
|
$share['url'] = \OC::$server->getURLGenerator()->linkToRouteAbsolute('files_sharing.sharecontroller.showShare', ['token' => $share['token']]); |
151
|
3 |
|
} |
152
|
5 |
|
} |
153
|
|
|
|
154
|
5 |
|
return new \OC_OCS_Result($shares); |
155
|
|
|
} |
156
|
|
|
} |
157
|
|
|
|
158
|
|
|
/** |
159
|
|
|
* add reshares to a array of shares |
160
|
|
|
* @param array $shares array of shares |
161
|
|
|
* @param int $itemSource item source ID |
162
|
|
|
* @return array new shares array which includes reshares |
163
|
|
|
*/ |
164
|
1 |
|
private static function addReshares($shares, $itemSource) { |
165
|
|
|
|
166
|
|
|
// if there are no shares than there are also no reshares |
167
|
1 |
|
$firstShare = reset($shares); |
168
|
1 |
|
if ($firstShare) { |
169
|
1 |
|
$path = $firstShare['path']; |
170
|
1 |
|
} else { |
171
|
|
|
return $shares; |
172
|
|
|
} |
173
|
|
|
|
174
|
1 |
|
$select = '`*PREFIX*share`.`id`, `item_type`, `*PREFIX*share`.`parent`, `share_type`, `share_with`, `file_source`, `path` , `*PREFIX*share`.`permissions`, `stime`, `expiration`, `token`, `storage`, `mail_send`, `mail_send`'; |
175
|
1 |
|
$getReshares = \OCP\DB::prepare('SELECT ' . $select . ' FROM `*PREFIX*share` INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid` WHERE `*PREFIX*share`.`file_source` = ? AND `*PREFIX*share`.`item_type` IN (\'file\', \'folder\') AND `uid_owner` != ?'); |
176
|
1 |
|
$reshares = $getReshares->execute(array($itemSource, \OCP\User::getUser()))->fetchAll(); |
177
|
|
|
|
178
|
1 |
|
foreach ($reshares as $key => $reshare) { |
179
|
1 |
|
if (isset($reshare['share_with']) && $reshare['share_with'] !== '') { |
180
|
1 |
|
$reshares[$key]['share_with_displayname'] = \OCP\User::getDisplayName($reshare['share_with']); |
181
|
1 |
|
} |
182
|
|
|
// add correct path to the result |
183
|
1 |
|
$reshares[$key]['path'] = $path; |
184
|
1 |
|
} |
185
|
|
|
|
186
|
1 |
|
return array_merge($shares, $reshares); |
187
|
|
|
} |
188
|
|
|
|
189
|
|
|
/** |
190
|
|
|
* get share from all files in a given folder (non-recursive) |
191
|
|
|
* @param string $path |
192
|
|
|
* @return \OC_OCS_Result |
193
|
|
|
*/ |
194
|
6 |
|
private static function getSharesFromFolder($path) { |
195
|
6 |
|
$view = new \OC\Files\View('/'.\OCP\User::getUser().'/files'); |
196
|
|
|
|
197
|
6 |
|
if(!$view->is_dir($path)) { |
198
|
1 |
|
return new \OC_OCS_Result(null, 400, "not a directory"); |
199
|
|
|
} |
200
|
|
|
|
201
|
5 |
|
$content = $view->getDirectoryContent($path); |
202
|
|
|
|
203
|
5 |
|
$result = array(); |
204
|
5 |
|
foreach ($content as $file) { |
205
|
|
|
// workaround because folders are named 'dir' in this context |
206
|
5 |
|
$itemType = $file['type'] === 'file' ? 'file' : 'folder'; |
207
|
5 |
|
$share = \OCP\Share::getItemShared($itemType, $file['fileid']); |
208
|
5 |
|
if($share) { |
|
|
|
|
209
|
5 |
|
$receivedFrom = \OCP\Share::getItemSharedWithBySource($itemType, $file['fileid']); |
210
|
5 |
|
reset($share); |
211
|
5 |
|
$key = key($share); |
212
|
5 |
|
if ($receivedFrom) { |
|
|
|
|
213
|
3 |
|
$share[$key]['received_from'] = $receivedFrom['uid_owner']; |
214
|
3 |
|
$share[$key]['received_from_displayname'] = \OCP\User::getDisplayName($receivedFrom['uid_owner']); |
215
|
3 |
|
} |
216
|
5 |
|
$result = array_merge($result, $share); |
217
|
5 |
|
} |
218
|
5 |
|
} |
219
|
|
|
|
220
|
5 |
|
return new \OC_OCS_Result($result); |
221
|
|
|
} |
222
|
|
|
|
223
|
|
|
/** |
224
|
|
|
* get files shared with the user |
225
|
|
|
* @return \OC_OCS_Result |
226
|
|
|
*/ |
227
|
1 |
|
private static function getFilesSharedWithMe() { |
228
|
|
|
try { |
229
|
1 |
|
$shares = \OCP\Share::getItemsSharedWith('file'); |
230
|
1 |
|
foreach ($shares as &$share) { |
231
|
1 |
View Code Duplication |
if ($share['item_type'] === 'file') { |
|
|
|
|
232
|
1 |
|
$share['mimetype'] = \OC_Helper::getFileNameMimeType($share['file_target']); |
233
|
1 |
|
if (\OC::$server->getPreviewManager()->isMimeSupported($share['mimetype'])) { |
234
|
1 |
|
$share['isPreviewAvailable'] = true; |
235
|
1 |
|
} |
236
|
1 |
|
} |
237
|
1 |
|
} |
238
|
1 |
|
$result = new \OC_OCS_Result($shares); |
239
|
1 |
|
} catch (\Exception $e) { |
240
|
|
|
$result = new \OC_OCS_Result(null, 403, $e->getMessage()); |
241
|
|
|
} |
242
|
|
|
|
243
|
1 |
|
return $result; |
244
|
|
|
|
245
|
|
|
} |
246
|
|
|
|
247
|
|
|
/** |
248
|
|
|
* create a new share |
249
|
|
|
* @param array $params |
250
|
|
|
* @return \OC_OCS_Result |
251
|
|
|
*/ |
252
|
18 |
|
public static function createShare($params) { |
|
|
|
|
253
|
|
|
|
254
|
18 |
|
$path = isset($_POST['path']) ? $_POST['path'] : null; |
255
|
|
|
|
256
|
18 |
|
if($path === null) { |
257
|
|
|
return new \OC_OCS_Result(null, 400, "please specify a file or folder path"); |
258
|
|
|
} |
259
|
18 |
|
$itemSource = self::getFileId($path); |
260
|
18 |
|
$itemSourceName = $itemSource; |
261
|
18 |
|
$itemType = self::getItemType($path); |
262
|
18 |
|
$expirationDate = null; |
263
|
|
|
|
264
|
18 |
|
if($itemSource === null) { |
265
|
|
|
return new \OC_OCS_Result(null, 404, "wrong path, file/folder doesn't exist."); |
266
|
|
|
} |
267
|
|
|
|
268
|
18 |
|
$shareWith = isset($_POST['shareWith']) ? $_POST['shareWith'] : null; |
269
|
18 |
|
$shareType = isset($_POST['shareType']) ? (int)$_POST['shareType'] : null; |
270
|
|
|
|
271
|
|
|
switch($shareType) { |
272
|
18 |
|
case \OCP\Share::SHARE_TYPE_REMOTE: |
273
|
|
|
$shareWith = rtrim($shareWith, '/'); |
274
|
|
|
$itemSourceName = basename($path); |
275
|
18 |
|
case \OCP\Share::SHARE_TYPE_USER: |
276
|
18 |
|
case \OCP\Share::SHARE_TYPE_GROUP: |
277
|
6 |
|
$permissions = isset($_POST['permissions']) ? (int)$_POST['permissions'] : 31; |
278
|
6 |
|
break; |
279
|
12 |
|
case \OCP\Share::SHARE_TYPE_LINK: |
280
|
|
|
//allow password protection |
281
|
12 |
|
$shareWith = isset($_POST['password']) ? $_POST['password'] : null; |
282
|
|
|
//check public link share |
283
|
12 |
|
$publicUploadEnabled = \OC::$server->getAppConfig()->getValue('core', 'shareapi_allow_public_upload', 'yes'); |
284
|
12 |
|
if(isset($_POST['publicUpload']) && $publicUploadEnabled !== 'yes') { |
285
|
|
|
return new \OC_OCS_Result(null, 403, "public upload disabled by the administrator"); |
286
|
|
|
} |
287
|
12 |
|
$publicUpload = isset($_POST['publicUpload']) ? $_POST['publicUpload'] : 'false'; |
288
|
|
|
// read, create, update (7) if public upload is enabled or |
289
|
|
|
// read (1) if public upload is disabled |
290
|
12 |
|
$permissions = $publicUpload === 'true' ? 7 : 1; |
291
|
|
|
|
292
|
|
|
// Get the expiration date |
293
|
|
|
try { |
294
|
12 |
|
$expirationDate = isset($_POST['expireDate']) ? self::parseDate($_POST['expireDate']) : null; |
295
|
12 |
|
} catch (\Exception $e) { |
296
|
4 |
|
return new \OC_OCS_Result(null, 404, 'Invalid Date. Format must be YYYY-MM-DD.'); |
297
|
|
|
} |
298
|
|
|
|
299
|
8 |
|
break; |
300
|
|
|
default: |
301
|
|
|
return new \OC_OCS_Result(null, 400, "unknown share type"); |
302
|
|
|
} |
303
|
|
|
|
304
|
14 |
|
if (($permissions & \OCP\Constants::PERMISSION_READ) === 0) { |
305
|
1 |
|
return new \OC_OCS_Result(null, 400, 'invalid permissions'); |
306
|
|
|
} |
307
|
|
|
|
308
|
|
|
try { |
309
|
13 |
|
$token = \OCP\Share::shareItem( |
310
|
13 |
|
$itemType, |
311
|
13 |
|
$itemSource, |
312
|
13 |
|
$shareType, |
313
|
13 |
|
$shareWith, |
314
|
13 |
|
$permissions, |
315
|
13 |
|
$itemSourceName, |
316
|
|
|
$expirationDate |
317
|
13 |
|
); |
318
|
13 |
|
} catch (HintException $e) { |
319
|
2 |
|
if ($e->getCode() === 0) { |
320
|
|
|
return new \OC_OCS_Result(null, 400, $e->getHint()); |
321
|
|
|
} else { |
322
|
2 |
|
return new \OC_OCS_Result(null, $e->getCode(), $e->getHint()); |
323
|
|
|
} |
324
|
2 |
|
} catch (\Exception $e) { |
325
|
2 |
|
return new \OC_OCS_Result(null, 403, $e->getMessage()); |
326
|
|
|
} |
327
|
|
|
|
328
|
11 |
|
if ($token) { |
329
|
11 |
|
$data = array(); |
330
|
11 |
|
$data['id'] = 'unknown'; |
331
|
11 |
|
$shares = \OCP\Share::getItemShared($itemType, $itemSource); |
332
|
11 |
|
if(is_string($token)) { //public link share |
333
|
6 |
|
foreach ($shares as $share) { |
334
|
6 |
|
if ($share['token'] === $token) { |
335
|
6 |
|
$data['id'] = $share['id']; |
336
|
6 |
|
break; |
337
|
|
|
} |
338
|
6 |
|
} |
339
|
6 |
|
$data['url'] = \OC::$server->getURLGenerator()->linkToRouteAbsolute('files_sharing.sharecontroller.showShare', ['token' => $token]); |
340
|
6 |
|
$data['token'] = $token; |
341
|
|
|
|
342
|
6 |
|
} else { |
343
|
5 |
|
foreach ($shares as $share) { |
344
|
5 |
|
if ($share['share_with'] === $shareWith && $share['share_type'] === $shareType) { |
345
|
5 |
|
$data['id'] = $share['id']; |
346
|
5 |
|
break; |
347
|
|
|
} |
348
|
5 |
|
} |
349
|
|
|
} |
350
|
|
|
|
351
|
11 |
|
$data['permissions'] = $share['permissions']; |
|
|
|
|
352
|
11 |
|
$data['expiration'] = $share['expiration']; |
353
|
|
|
|
354
|
11 |
|
return new \OC_OCS_Result($data); |
355
|
|
|
} else { |
356
|
|
|
return new \OC_OCS_Result(null, 404, "couldn't share file"); |
357
|
|
|
} |
358
|
|
|
} |
359
|
|
|
|
360
|
|
|
/** |
361
|
|
|
* update shares, e.g. password, permissions, etc |
362
|
|
|
* @param array $params shareId 'id' and the parameter we want to update |
363
|
|
|
* currently supported: permissions, password, publicUpload |
364
|
|
|
* @return \OC_OCS_Result |
365
|
|
|
*/ |
366
|
5 |
|
public static function updateShare($params) { |
367
|
|
|
|
368
|
5 |
|
$share = self::getShareFromId($params['id']); |
369
|
|
|
|
370
|
5 |
|
if(!isset($share['file_source'])) { |
371
|
|
|
return new \OC_OCS_Result(null, 404, "wrong share Id, share doesn't exist."); |
372
|
|
|
} |
373
|
|
|
|
374
|
|
|
try { |
375
|
5 |
|
if(isset($params['_put']['permissions'])) { |
376
|
2 |
|
return self::updatePermissions($share, $params); |
377
|
4 |
|
} elseif (isset($params['_put']['password'])) { |
378
|
2 |
|
return self::updatePassword($params['id'], (int)$share['share_type'], $params['_put']['password']); |
379
|
2 |
|
} elseif (isset($params['_put']['publicUpload'])) { |
380
|
1 |
|
return self::updatePublicUpload($share, $params); |
381
|
1 |
|
} elseif (isset($params['_put']['expireDate'])) { |
382
|
1 |
|
return self::updateExpireDate($share, $params); |
383
|
|
|
} |
384
|
|
|
} catch (\Exception $e) { |
385
|
|
|
|
386
|
|
|
return new \OC_OCS_Result(null, 400, $e->getMessage()); |
387
|
|
|
} |
388
|
|
|
|
389
|
|
|
return new \OC_OCS_Result(null, 400, "Wrong or no update parameter given"); |
390
|
|
|
} |
391
|
|
|
|
392
|
|
|
/** |
393
|
|
|
* update permissions for a share |
394
|
|
|
* @param array $share information about the share |
395
|
|
|
* @param array $params contains 'permissions' |
396
|
|
|
* @return \OC_OCS_Result |
397
|
|
|
*/ |
398
|
3 |
|
private static function updatePermissions($share, $params) { |
399
|
|
|
|
400
|
3 |
|
$itemSource = $share['item_source']; |
401
|
3 |
|
$itemType = $share['item_type']; |
402
|
3 |
|
$shareWith = $share['share_with']; |
403
|
3 |
|
$shareType = $share['share_type']; |
404
|
3 |
|
$permissions = isset($params['_put']['permissions']) ? (int)$params['_put']['permissions'] : null; |
405
|
|
|
|
406
|
3 |
|
$publicUploadStatus = \OC::$server->getAppConfig()->getValue('core', 'shareapi_allow_public_upload', 'yes'); |
407
|
3 |
|
$publicUploadEnabled = ($publicUploadStatus === 'yes') ? true : false; |
408
|
|
|
|
409
|
|
|
|
410
|
|
|
// only change permissions for public shares if public upload is enabled |
411
|
|
|
// and we want to set permissions to 1 (read only) or 7 (allow upload) |
412
|
3 |
|
if ( (int)$shareType === \OCP\Share::SHARE_TYPE_LINK ) { |
413
|
1 |
|
if ($publicUploadEnabled === false || ($permissions !== 7 && $permissions !== 1)) { |
414
|
|
|
return new \OC_OCS_Result(null, 400, "can't change permission for public link share"); |
415
|
|
|
} |
416
|
1 |
|
} |
417
|
|
|
|
418
|
3 |
|
if (($permissions & \OCP\Constants::PERMISSION_READ) === 0) { |
419
|
1 |
|
return new \OC_OCS_Result(null, 400, 'invalid permissions'); |
420
|
|
|
} |
421
|
|
|
|
422
|
|
|
try { |
423
|
2 |
|
$return = \OCP\Share::setPermissions( |
424
|
2 |
|
$itemType, |
425
|
2 |
|
$itemSource, |
426
|
2 |
|
$shareType, |
427
|
2 |
|
$shareWith, |
428
|
|
|
$permissions |
429
|
2 |
|
); |
430
|
2 |
|
} catch (\Exception $e) { |
431
|
|
|
return new \OC_OCS_Result(null, 404, $e->getMessage()); |
432
|
|
|
} |
433
|
|
|
|
434
|
2 |
|
if ($return) { |
435
|
2 |
|
return new \OC_OCS_Result(); |
436
|
|
|
} else { |
437
|
|
|
return new \OC_OCS_Result(null, 404, "couldn't set permissions"); |
438
|
|
|
} |
439
|
|
|
} |
440
|
|
|
|
441
|
|
|
/** |
442
|
|
|
* enable/disable public upload |
443
|
|
|
* @param array $share information about the share |
444
|
|
|
* @param array $params contains 'publicUpload' which can be 'yes' or 'no' |
445
|
|
|
* @return \OC_OCS_Result |
446
|
|
|
*/ |
447
|
1 |
|
private static function updatePublicUpload($share, $params) { |
448
|
|
|
|
449
|
1 |
|
$publicUploadEnabled = \OC::$server->getAppConfig()->getValue('core', 'shareapi_allow_public_upload', 'yes'); |
450
|
1 |
|
if($publicUploadEnabled !== 'yes') { |
451
|
|
|
return new \OC_OCS_Result(null, 403, "public upload disabled by the administrator"); |
452
|
|
|
} |
453
|
|
|
|
454
|
1 |
|
if ($share['item_type'] !== 'folder' || |
455
|
1 |
|
(int)$share['share_type'] !== \OCP\Share::SHARE_TYPE_LINK ) { |
456
|
|
|
return new \OC_OCS_Result(null, 400, "public upload is only possible for public shared folders"); |
457
|
|
|
} |
458
|
|
|
|
459
|
|
|
// read, create, update (7) if public upload is enabled or |
460
|
|
|
// read (1) if public upload is disabled |
461
|
1 |
|
$params['_put']['permissions'] = $params['_put']['publicUpload'] === 'true' ? 7 : 1; |
462
|
|
|
|
463
|
1 |
|
return self::updatePermissions($share, $params); |
464
|
|
|
|
465
|
|
|
} |
466
|
|
|
|
467
|
|
|
/** |
468
|
|
|
* set expire date for public link share |
469
|
|
|
* @param array $share information about the share |
470
|
|
|
* @param array $params contains 'expireDate' which needs to be a well formated date string, e.g DD-MM-YYYY |
471
|
|
|
* @return \OC_OCS_Result |
472
|
|
|
*/ |
473
|
1 |
|
private static function updateExpireDate($share, $params) { |
474
|
|
|
// only public links can have a expire date |
475
|
1 |
|
if ((int)$share['share_type'] !== \OCP\Share::SHARE_TYPE_LINK ) { |
476
|
|
|
return new \OC_OCS_Result(null, 400, "expire date only exists for public link shares"); |
477
|
|
|
} |
478
|
|
|
|
479
|
|
|
try { |
480
|
1 |
|
$expireDateSet = \OCP\Share::setExpirationDate($share['item_type'], $share['item_source'], $params['_put']['expireDate'], (int)$share['stime']); |
481
|
1 |
|
$result = ($expireDateSet) ? new \OC_OCS_Result() : new \OC_OCS_Result(null, 404, "couldn't set expire date"); |
482
|
1 |
|
} catch (\Exception $e) { |
483
|
1 |
|
$result = new \OC_OCS_Result(null, 404, $e->getMessage()); |
484
|
|
|
} |
485
|
|
|
|
486
|
1 |
|
return $result; |
487
|
|
|
|
488
|
|
|
} |
489
|
|
|
|
490
|
|
|
/** |
491
|
|
|
* update password for public link share |
492
|
|
|
* @param int $shareId |
493
|
|
|
* @param int $shareType |
494
|
|
|
* @param string $password |
495
|
|
|
* @return \OC_OCS_Result |
496
|
|
|
*/ |
497
|
2 |
|
private static function updatePassword($shareId, $shareType, $password) { |
498
|
2 |
|
if($shareType !== \OCP\Share::SHARE_TYPE_LINK) { |
499
|
|
|
return new \OC_OCS_Result(null, 400, "password protection is only supported for public shares"); |
500
|
|
|
} |
501
|
|
|
|
502
|
2 |
|
if($password === '') { |
503
|
2 |
|
$password = null; |
504
|
2 |
|
} |
505
|
|
|
|
506
|
|
|
try { |
507
|
2 |
|
$result = \OCP\Share::setPassword($shareId, $password); |
508
|
2 |
|
} catch (\Exception $e) { |
509
|
1 |
|
return new \OC_OCS_Result(null, 403, $e->getMessage()); |
510
|
|
|
} |
511
|
|
|
|
512
|
2 |
|
if($result) { |
513
|
2 |
|
return new \OC_OCS_Result(); |
514
|
|
|
} |
515
|
|
|
|
516
|
|
|
return new \OC_OCS_Result(null, 404, "couldn't set password"); |
517
|
|
|
} |
518
|
|
|
|
519
|
|
|
/** |
520
|
|
|
* unshare a file/folder |
521
|
|
|
* @param array $params contains the shareID 'id' which should be unshared |
522
|
|
|
* @return \OC_OCS_Result |
523
|
|
|
*/ |
524
|
2 |
|
public static function deleteShare($params) { |
525
|
|
|
|
526
|
2 |
|
$share = self::getShareFromId($params['id']); |
527
|
2 |
|
$fileSource = isset($share['file_source']) ? $share['file_source'] : null; |
528
|
2 |
|
$itemType = isset($share['item_type']) ? $share['item_type'] : null;; |
529
|
|
|
|
530
|
2 |
|
if($fileSource === null) { |
531
|
|
|
return new \OC_OCS_Result(null, 404, "wrong share ID, share doesn't exist."); |
532
|
|
|
} |
533
|
|
|
|
534
|
2 |
|
$shareWith = isset($share['share_with']) ? $share['share_with'] : null; |
535
|
2 |
|
$shareType = isset($share['share_type']) ? (int)$share['share_type'] : null; |
536
|
|
|
|
537
|
2 |
|
if( $shareType === \OCP\Share::SHARE_TYPE_LINK) { |
538
|
2 |
|
$shareWith = null; |
539
|
2 |
|
} |
540
|
|
|
|
541
|
|
|
try { |
542
|
2 |
|
$return = \OCP\Share::unshare( |
543
|
2 |
|
$itemType, |
544
|
2 |
|
$fileSource, |
545
|
2 |
|
$shareType, |
546
|
2 |
|
$shareWith); |
547
|
2 |
|
} catch (\Exception $e) { |
548
|
|
|
return new \OC_OCS_Result(null, 404, $e->getMessage()); |
549
|
|
|
} |
550
|
|
|
|
551
|
2 |
|
if ($return) { |
552
|
2 |
|
return new \OC_OCS_Result(); |
553
|
|
|
} else { |
554
|
|
|
$msg = "Unshare Failed"; |
555
|
|
|
return new \OC_OCS_Result(null, 404, $msg); |
556
|
|
|
} |
557
|
|
|
} |
558
|
|
|
|
559
|
|
|
/** |
560
|
|
|
* Make sure that the passed date is valid ISO 8601 |
561
|
|
|
* So YYYY-MM-DD |
562
|
|
|
* If not throw an exception |
563
|
|
|
* |
564
|
|
|
* @param string $expireDate |
565
|
|
|
* |
566
|
|
|
* @throws \Exception |
567
|
|
|
* @return \DateTime |
568
|
|
|
*/ |
569
|
8 |
|
private static function parseDate($expireDate) { |
570
|
8 |
|
if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $expireDate) === 0) { |
571
|
4 |
|
throw new \Exception('Invalid date. Format must be YYYY-MM-DD'); |
572
|
|
|
} |
573
|
|
|
|
574
|
4 |
|
$date = new \DateTime($expireDate); |
575
|
|
|
|
576
|
4 |
|
if ($date === false) { |
577
|
|
|
throw new \Exception('Invalid date. Format must be YYYY-MM-DD'); |
578
|
|
|
} |
579
|
|
|
|
580
|
4 |
|
return $date; |
581
|
|
|
} |
582
|
|
|
|
583
|
|
|
/** |
584
|
|
|
* get file ID from a given path |
585
|
|
|
* @param string $path |
586
|
|
|
* @return string fileID or null |
587
|
|
|
*/ |
588
|
21 |
View Code Duplication |
private static function getFileId($path) { |
589
|
|
|
|
590
|
21 |
|
$view = new \OC\Files\View('/'.\OCP\User::getUser().'/files'); |
591
|
21 |
|
$fileId = null; |
592
|
21 |
|
$fileInfo = $view->getFileInfo($path); |
593
|
21 |
|
if ($fileInfo) { |
594
|
21 |
|
$fileId = $fileInfo['fileid']; |
595
|
21 |
|
} |
596
|
|
|
|
597
|
21 |
|
return $fileId; |
598
|
|
|
} |
599
|
|
|
|
600
|
|
|
/** |
601
|
|
|
* get itemType |
602
|
|
|
* @param string $path |
603
|
|
|
* @return string type 'file', 'folder' or null of file/folder doesn't exists |
604
|
|
|
*/ |
605
|
21 |
View Code Duplication |
private static function getItemType($path) { |
606
|
21 |
|
$view = new \OC\Files\View('/'.\OCP\User::getUser().'/files'); |
607
|
21 |
|
$itemType = null; |
608
|
|
|
|
609
|
21 |
|
if ($view->is_dir($path)) { |
610
|
15 |
|
$itemType = "folder"; |
611
|
21 |
|
} elseif ($view->is_file($path)) { |
612
|
6 |
|
$itemType = "file"; |
613
|
6 |
|
} |
614
|
|
|
|
615
|
21 |
|
return $itemType; |
616
|
|
|
} |
617
|
|
|
|
618
|
|
|
/** |
619
|
|
|
* get some information from a given share |
620
|
|
|
* @param int $shareID |
621
|
|
|
* @return array with: item_source, share_type, share_with, item_type, permissions |
622
|
|
|
*/ |
623
|
10 |
|
private static function getShareFromId($shareID) { |
624
|
10 |
|
$sql = 'SELECT `file_source`, `item_source`, `share_type`, `share_with`, `item_type`, `permissions`, `stime` FROM `*PREFIX*share` WHERE `id` = ?'; |
625
|
10 |
|
$args = array($shareID); |
626
|
10 |
|
$query = \OCP\DB::prepare($sql); |
627
|
10 |
|
$result = $query->execute($args); |
628
|
|
|
|
629
|
10 |
|
if (\OCP\DB::isError($result)) { |
630
|
|
|
\OCP\Util::writeLog('files_sharing', \OCP\DB::getErrorMessage(), \OCP\Util::ERROR); |
631
|
|
|
return null; |
632
|
|
|
} |
633
|
10 |
|
if ($share = $result->fetchRow()) { |
634
|
9 |
|
return $share; |
635
|
|
|
} |
636
|
|
|
|
637
|
1 |
|
return null; |
638
|
|
|
|
639
|
|
|
} |
640
|
|
|
|
641
|
|
|
} |
642
|
|
|
|
This check looks from parameters that have been defined for a function or method, but which are not used in the method body.