|
1
7 package com.dotmarketing.cache;
8
9 import java.io.FileInputStream  ;
10 import java.io.FileNotFoundException ;
11 import java.io.IOException ;
12 import java.util.ArrayList ;
13 import java.util.Iterator ;
14 import java.util.List ;
15 import java.util.Properties ;
16
17 import com.dotmarketing.beans.Host;
18 import com.dotmarketing.beans.Identifier;
19 import com.dotmarketing.beans.Inode;
20 import com.dotmarketing.beans.Permission;
21 import com.dotmarketing.beans.WebAsset;
22 import com.dotmarketing.cms.factories.PublicRoleFactory;
23 import com.dotmarketing.factories.HostFactory;
24 import com.dotmarketing.factories.IdentifierFactory;
25 import com.dotmarketing.factories.InodeFactory;
26 import com.dotmarketing.factories.PermissionFactory;
27 import com.dotmarketing.portlets.files.model.File;
28 import com.dotmarketing.portlets.folders.model.Folder;
29 import com.dotmarketing.portlets.htmlpages.model.HTMLPage;
30 import com.dotmarketing.util.Config;
31 import com.dotmarketing.util.Logger;
32 import com.dotmarketing.util.UtilMethods;
33 import com.liferay.portal.ejb.RoleLocalManagerUtil;
34 import com.liferay.portal.model.Role;
35
36
40 public class PermissionCache {
41 private static DotCache cache;
43
44 private static String providerEntry = "CACHE_PROVIDER";
46
47 private static String propertiesEntry = "CACHE_PROPERTIES_FILE";
49
50 private static String regionName = "PermissionCache";
52
53 static {
54 init();
55 }
56
57 public static List addToPermissionCache(String key, List permissions) {
58 if (cache.get(key) != null) {
60 cache.remove(String.valueOf(key));
61 }
62 cache.put(key, permissions);
64
65 return permissions;
66 }
67
68 public static List addToPermissionCache(Host host) {
69 List permissions = PermissionFactory.getPermissions(host);
71 String key = String.valueOf(host.getInode());
72 return addToPermissionCache(key, permissions);
73 }
74
75 public static List addToPermissionCache(Folder folder) {
76 List permissions = PermissionFactory.getPermissionsFromFolder(folder);
77 addToPermissionCache(String.valueOf(folder.getInode()), permissions);
78
79 List webPages = InodeFactory.getChildrenClass(folder, HTMLPage.class);
80 Iterator it = webPages.iterator();
81 while (it.hasNext()) {
82 HTMLPage page = (HTMLPage) it.next();
83 addToPermissionCache(page);
84 }
85 return permissions;
86 }
87
88 public static List addToPermissionCache(WebAsset webAsset) {
89
90 long id = webAsset.getIdentifier();
91
92 if(id == 0){
93 id = IdentifierCache.getIdentifierByInodeFromCache(webAsset).getInode();
94 }
95
96
97 List permissions = PermissionFactory.getPermissionsFromWebAsset(webAsset);
98 if (webAsset instanceof HTMLPage) {
99 Folder parentFolder = (Folder) InodeFactory.getParentOfClass(webAsset, Folder.class);
100 Host parentHost = HostFactory.getParentHost(webAsset);
101 addToPermissionCache(parentHost.getInode() + "-" + webAsset.getURI(parentFolder), permissions);
103 addToPermissionCache(String.valueOf(id), permissions);
104 } else {
105 addToPermissionCache(String.valueOf(id), permissions);
106 }
107
108 return permissions;
109 }
110
111 public static List addToPermissionCache(Identifier id) {
112 if (id == null || id.getInode() == 0) {
113 return new ArrayList ();
114 }
115
116 List permissions = PermissionFactory.getPermissionsFromIdentifier(id);
117 addToPermissionCache(String.valueOf(id.getInode()), permissions);
118
119 return permissions;
120 }
121
122 public static List addToPermissionCache(long hostId, String URI) {
123 Identifier id = IdentifierFactory.getIdentifierByURI(URI, hostId);
124
125 if (id.getInode() == 0)
126 return new ArrayList ();
127
128 WebAsset asset = null;
129
130 if (URI.endsWith("." + Config.getStringProperty("VELOCITY_PAGE_EXTENSION"))) {
131 asset = (WebAsset) IdentifierFactory.getWorkingChildOfClass(id, HTMLPage.class);
132 } else {
133 asset = (WebAsset) IdentifierFactory.getWorkingChildOfClass(id, File.class);
134 }
135
136 Folder parentFolder = (Folder) InodeFactory.getParentOfClass(asset, Folder.class);
137 List permissions = PermissionFactory.getPermissionsFromWebAsset(asset);
138
139 if (asset instanceof HTMLPage) {
140 Host parentHost = HostFactory.getParentHost(asset);
141 PermissionCache.addToPermissionCache(parentHost.getInode() + "-" + asset.getURI(parentFolder), permissions);
143 addToPermissionCache(String.valueOf(id.getInode()), permissions);
144 } else {
145 PermissionCache.addToPermissionCache(String.valueOf(parentFolder.getInode()), permissions);
146 }
147
148 return permissions;
149 }
150
151 public static List getPermissionsFromCache(Host host) {
152 String key = String.valueOf(host.getInode());
153 List perms = (List ) cache.get(key);
154 if (perms == null) {
156 perms = PermissionCache.addToPermissionCache(host);
158 }
159 return perms;
160 }
161
162 public static List getPermissionsFromCache(Folder folder) {
163 String key = String.valueOf(folder.getInode());
164 List perms = (List ) cache.get(key);
165 if (perms == null) {
167 perms = PermissionCache.addToPermissionCache(folder);
169 }
170 return perms;
171 }
172
173 public static List getPermissionsFromCache(String URI, Host host) {
174 return getPermissionsFromCache(URI, host.getInode());
175 }
176
177 public static List getPermissionsFromCache(String URI, long hostId) {
178 String key = String.valueOf(hostId) + "-" + URI;
179 List perms = (List ) cache.get(key);
180 if (perms == null) {
181 perms = addToPermissionCache(hostId, URI);
183 }
184 List emptyperms = new ArrayList ();
185 return (perms == null ? emptyperms : perms);
186 }
187
188
204 @SuppressWarnings ("unchecked")
205 public static List <Permission> getPermissionsFromCache(WebAsset webAsset) {
206 long id = webAsset.getIdentifier();
207
208 if(id == 0){
209 id = IdentifierCache.getIdentifierByInodeFromCache(webAsset).getInode();
210 }
211
212 if (id == 0) {
214 return new ArrayList <Permission>();
215 }
216
217 List <Permission> permissions = (List <Permission>) cache.get(String.valueOf(id));
218 if (permissions == null) {
219 permissions = addToPermissionCache(webAsset);
220 }
221
222 return permissions;
223 }
224
225
241 public static List getPermissionsFromCache(Identifier id) {
242
243 if (id.getInode() == 0) {
245 return new ArrayList ();
246 }
247
248 List permissions = (List ) cache.get(String.valueOf(id.getInode()));
249 if (permissions == null) {
250 permissions = addToPermissionCache(id);
251 }
252
253 return permissions;
254 }
255
256 public static List getRoleNamesWithReadPermissionFromCache(String URI, Host host) {
257 return getRoleNamesWithReadPermissionFromCache(URI, host.getInode());
258 }
259
260 public static List getRoleNamesWithReadPermissionFromCache(String URI, long hostId) {
261 List perms = getPermissionsFromCache(URI, hostId);
262 List <String > readPerms = new ArrayList <String >();
263 Iterator it = perms.iterator();
264 int permissionReadCode = Config.getIntProperty("PERMISSION_READ");
265 while (it.hasNext()) {
266 Permission perm = (Permission) it.next();
267 if (perm.getPermission() == permissionReadCode) {
268 Role role;
269 try {
270 role = RoleLocalManagerUtil.getRoleById(String.valueOf(perm.getRoleId()));
271 readPerms.add(role.getName());
272 } catch (Exception e) {
273 }
274 }
275 }
276 return readPerms;
277 }
278
279
288 public static List getReadPermissionsFromCache(String URI, Host host) {
289 return getReadPermissionsFromCache(URI, host.getInode());
290 }
291
292 public static List getReadPermissionsFromCache(String URI, long hostId) {
293 List perms = getPermissionsFromCache(URI, hostId);
294 List <Permission> readPerms = new ArrayList <Permission>();
295 Iterator it = perms.iterator();
296 int permissionReadCode = Config.getIntProperty("PERMISSION_READ");
297 while (it.hasNext()) {
298 Permission perm = (Permission) it.next();
299 if (perm.getPermission() == permissionReadCode)
300 readPerms.add(perm);
301 }
302 return readPerms;
303 }
304
305 public static List getWritePermissionsFromCache(String URI, Host host) {
306 return getWritePermissionsFromCache(URI, host.getInode());
307 }
308
309 public static List getWritePermissionsFromCache(String URI, long hostId) {
310 List perms = getPermissionsFromCache(URI, hostId);
311 List <Permission> readPerms = new ArrayList <Permission>();
312 Iterator it = perms.iterator();
313 int permissionReadCode = Config.getIntProperty("PERMISSION_WRITE");
314 while (it.hasNext()) {
315 Permission perm = (Permission) it.next();
316 if (perm.getPermission() == permissionReadCode)
317 readPerms.add(perm);
318 }
319 return readPerms;
320 }
321
322 public static List getPublishPermissionsFromCache(String URI, Host host) {
323 return getPublishPermissionsFromCache(URI, host.getInode());
324 }
325
326 public static List getPublishPermissionsFromCache(String URI, long hostId) {
327 List perms = getPermissionsFromCache(URI, hostId);
328 List <Permission> readPerms = new ArrayList <Permission>();
329 Iterator it = perms.iterator();
330 int permissionReadCode = Config.getIntProperty("PERMISSION_PUBLISH");
331 while (it.hasNext()) {
332 Permission perm = (Permission) it.next();
333 if (perm.getPermission() == permissionReadCode)
334 readPerms.add(perm);
335 }
336 return readPerms;
337 }
338
339 public static List getReadPermissionsFromCache(Host host) {
340 List perms = getPermissionsFromCache(host);
341 List readPerms = new ArrayList ();
342 Iterator it = perms.iterator();
343 int permissionReadCode = Config.getIntProperty("PERMISSION_READ");
344 while (it.hasNext()) {
345 Permission perm = (Permission) it.next();
346 if (perm.getPermission() == permissionReadCode)
347 readPerms.add(perm);
348 }
349 return readPerms;
350 }
351
352 public static List getWritePermissionsFromCache(Host host) {
353 List perms = getPermissionsFromCache(host);
354 List readPerms = new ArrayList ();
355 Iterator it = perms.iterator();
356 int permissionReadCode = Config.getIntProperty("PERMISSION_WRITE");
357 while (it.hasNext()) {
358 Permission perm = (Permission) it.next();
359 if (perm.getPermission() == permissionReadCode)
360 readPerms.add(perm);
361 }
362 return readPerms;
363 }
364
365 public static List getPublishPermissionsFromCache(Host host) {
366 List perms = getPermissionsFromCache(host);
367 List readPerms = new ArrayList ();
368 Iterator it = perms.iterator();
369 int permissionReadCode = Config.getIntProperty("PERMISSION_PUBLISH");
370 while (it.hasNext()) {
371 Permission perm = (Permission) it.next();
372 if (perm.getPermission() == permissionReadCode)
373 readPerms.add(perm);
374 }
375 return readPerms;
376 }
377
378 public static List getReadPermissionsFromCache(Folder folder) {
379 List perms = getPermissionsFromCache(folder);
380 List readPerms = new ArrayList ();
381 Iterator it = perms.iterator();
382 int permissionReadCode = Config.getIntProperty("PERMISSION_READ");
383 while (it.hasNext()) {
384 Permission perm = (Permission) it.next();
385 if (perm.getPermission() == permissionReadCode)
386 readPerms.add(perm);
387 }
388 return readPerms;
389 }
390
391 public static List getWritePermissionsFromCache(Folder folder) {
392 List perms = getPermissionsFromCache(folder);
393 List readPerms = new ArrayList ();
394 Iterator it = perms.iterator();
395 int permissionReadCode = Config.getIntProperty("PERMISSION_WRITE");
396 while (it.hasNext()) {
397 Permission perm = (Permission) it.next();
398 if (perm.getPermission() == permissionReadCode)
399 readPerms.add(perm);
400 }
401 return readPerms;
402 }
403
404 public static List getPublishPermissionsFromCache(Folder folder) {
405 List perms = getPermissionsFromCache(folder);
406 List readPerms = new ArrayList ();
407 Iterator it = perms.iterator();
408 int permissionReadCode = Config.getIntProperty("PERMISSION_PUBLISH");
409 while (it.hasNext()) {
410 Permission perm = (Permission) it.next();
411 if (perm.getPermission() == permissionReadCode)
412 readPerms.add(perm);
413 }
414 return readPerms;
415 }
416
417 public static List getReadPermissionsFromCache(WebAsset asset) {
418 List perms = getPermissionsFromCache(asset);
419 List readPerms = new ArrayList ();
420 Iterator it = perms.iterator();
421 int permissionReadCode = Config.getIntProperty("PERMISSION_READ");
422 while (it.hasNext()) {
423 Permission perm = (Permission) it.next();
424 if (perm.getPermission() == permissionReadCode)
425 readPerms.add(perm);
426 }
427 return readPerms;
428 }
429
430 public static List getWritePermissionsFromCache(WebAsset asset) {
431 List perms = getPermissionsFromCache(asset);
432 List readPerms = new ArrayList ();
433 Iterator it = perms.iterator();
434 int permissionReadCode = Config.getIntProperty("PERMISSION_WRITE");
435 while (it.hasNext()) {
436 Permission perm = (Permission) it.next();
437 if (perm.getPermission() == permissionReadCode)
438 readPerms.add(perm);
439 }
440 return readPerms;
441 }
442
443 public static List getPublishPermissionsFromCache(WebAsset asset) {
444 List perms = getPermissionsFromCache(asset);
445 List readPerms = new ArrayList ();
446 Iterator it = perms.iterator();
447 int permissionReadCode = Config.getIntProperty("PERMISSION_PUBLISH");
448 while (it.hasNext()) {
449 Permission perm = (Permission) it.next();
450 if (perm.getPermission() == permissionReadCode)
451 readPerms.add(perm);
452 }
453 return readPerms;
454 }
455
456 @SuppressWarnings ("unchecked")
457 public static List <String > getPermissionIdsByRolesFromCache(Inode inode, Role[] roles) {
458 List permissions = new ArrayList ();
459 List <Permission> assetsPermissions;
460
461 for (int i = 0; i < roles.length; i++) {
462
466 try {
467 if (roles[i].getRoleId().equals(PublicRoleFactory.getCMSAdminRole().getRoleId())) {
468 permissions.add(String.valueOf(Config.getIntProperty("PERMISSION_PUBLISH")));
469 permissions.add(String.valueOf(Config.getIntProperty("PERMISSION_READ")));
470 permissions.add(String.valueOf(Config.getIntProperty("PERMISSION_WRITE")));
471 return permissions;
472 }
473 } catch (Exception e) {
474
475 }
476 }
477
478
479
480
481 if (inode instanceof Folder) {
482 assetsPermissions = getPermissionsFromCache((Folder) inode);
483 } else if (inode instanceof WebAsset) {
484 assetsPermissions = getPermissionsFromCache((WebAsset) inode);
485 } else if (inode instanceof Host) {
486 assetsPermissions = getPermissionsFromCache((Host) inode);
487 } else {
488 return permissions;
489 }
490
491 for (int i = 0; i < roles.length; i++)
492 {
493 Iterator it = assetsPermissions.iterator();
494 while (it.hasNext()) {
495 Permission perm = (Permission) it.next();
496
497 if (perm.getRoleId() == Long.parseLong(roles[i].getRoleId()))
498 {
499 permissions.add(String.valueOf(perm.getPermission()));
500 }
501 }
502 }
503 return permissions;
504 }
505
506 public static void removeFolderFromPermissionCache(Folder folder) {
507 String key = String.valueOf(folder.getInode());
508 cache.remove(key);
509 }
510
511 public static void removeURIFromPermissionCache(String URI, Host host) {
514 removeURIFromPermissionCache(URI, host.getInode());
515 }
516
517 public static void removeURIFromPermissionCache(String URI, long hostId) {
518 String key = String.valueOf(hostId) + "-" + URI;
519 cache.remove(key);
520 }
521
522 public static void removeAssetFromPermissionCache(WebAsset asset) {
525 Folder parentFolder = (Folder) InodeFactory.getParentOfClass(asset, Folder.class);
526 removeFolderFromPermissionCache(parentFolder);
527 }
528
529 public static void clearCache() {
530 cache.clear();
532 }
533
534 private static void init() {
535 try {
536 Properties PermissionProperties = new Properties ();
537 String cacheProviderClassName = com.dotmarketing.util.Config.getStringProperty(providerEntry);
538 try {
539 String propertyFilePath = com.dotmarketing.util.Config.getStringProperty(propertiesEntry);
540 if (UtilMethods.isSet(propertyFilePath)) {
541 FileInputStream fileInputStream = new FileInputStream (propertyFilePath);
542 PermissionProperties.load(fileInputStream);
543 }
544 } catch (FileNotFoundException ex) {
545
546 String propertyFileNotFound = "The property file has been no found \n";
547 Logger.debug(PermissionCache.class, propertyFileNotFound + ex.getMessage());
548 } catch (IOException ex) {
549 Logger.debug(PermissionCache.class, ex.getMessage());
550 } finally {
551 cache = new DotCache(cacheProviderClassName, regionName, PermissionProperties);
552 }
553 } catch (Exception ex) {
554 Logger.error(PermissionCache.class, ex.toString());
555 }
556 }
557 }
558 |
Popular Tags |
Java API By Example, From Geeks To Geeks.