|
1 package com.dotmarketing.portlets.browser.ajax;
2
3 import java.util.ArrayList  ;
4 import java.util.Collections ;
5 import java.util.HashMap ;
6 import java.util.List ;
7 import java.util.Map ;
8
9 import javax.servlet.http.HttpServletRequest ;
10
11 import uk.ltd.getahead.dwr.WebContext;
12 import uk.ltd.getahead.dwr.WebContextFactory;
13
14 import com.dotmarketing.beans.Host;
15 import com.dotmarketing.beans.Inode;
16 import com.dotmarketing.beans.WebAsset;
17 import com.dotmarketing.cache.PermissionCache;
18 import com.dotmarketing.comparators.WebAssetMapComparator;
19 import com.dotmarketing.db.DbConnectionFactory;
20 import com.dotmarketing.exception.DotRuntimeException;
21 import com.dotmarketing.factories.HostFactory;
22 import com.dotmarketing.factories.InodeFactory;
23 import com.dotmarketing.factories.PermissionFactory;
24 import com.dotmarketing.factories.PublishFactory;
25 import com.dotmarketing.factories.RoleFactory;
26 import com.dotmarketing.factories.WebAssetFactory;
27 import com.dotmarketing.portlets.files.factories.FileFactory;
28 import com.dotmarketing.portlets.files.model.File;
29 import com.dotmarketing.portlets.folders.factories.FolderFactory;
30 import com.dotmarketing.portlets.folders.model.Folder;
31 import com.dotmarketing.portlets.htmlpages.factories.HTMLPageFactory;
32 import com.dotmarketing.portlets.htmlpages.model.HTMLPage;
33 import com.dotmarketing.portlets.links.factories.LinkFactory;
34 import com.dotmarketing.portlets.links.model.Link;
35 import com.dotmarketing.util.Config;
36 import com.dotmarketing.util.Logger;
37 import com.dotmarketing.util.UtilMethods;
38 import com.liferay.portal.model.Role;
39 import com.liferay.portal.model.User;
40 import com.liferay.portal.struts.ActionException;
41
42
47 public class BrowserAjax {
48
49 long activeHostInode = 0;
50 long activeFolderInode = 0;
51 List <Long > openFolders = new ArrayList <Long > ();
52
53 String lastSortBy = "name";
54 boolean lastSortDirectionDesc = false;
55
56
60 public List <Map > getTree () {
61 WebContext ctx = WebContextFactory.get();
62 User usr = getUser(ctx.getHttpServletRequest());
63 Role[] roles = RoleFactory.getAllRolesForUser(usr.getUserId()).toArray(new Role[0]);
64
65 List <Host> hosts = HostFactory.getAllHosts();
66 List <Map > retList = new ArrayList <Map >();
67 for (Host host : hosts) {
68 Map <String ,Object > hostMap = (Map <String ,Object >)host.getMap();
69 if (activeHostInode == host.getInode() || hosts.size() == 1) {
70 hostMap.put("open", true);
71 List <Map > children = getFoldersTree (host);
72 hostMap.put("childrenFolders", children);
73 hostMap.put("childrenFoldersCount", children.size());
74 } else {
75 hostMap.put("open", false);
76 hostMap.put("childrenFoldersCount", getSubFoldersCount(host));
77 }
78 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(host, roles);
79 hostMap.put("permissions", permissions);
80 retList.add(hostMap);
81 }
82 return retList;
83 }
84
85
90 public List <Map > openHostTree (long hostInode) {
91 Host host = (Host) InodeFactory.getInode(hostInode, Host.class);
92 activeHostInode = hostInode;
93 return getFoldersTree (host);
94 }
95
96
101 public List <Map > openFolderTree (long parentInode) {
102 Folder f = (Folder) InodeFactory.getInode(parentInode, Folder.class);
103 openFolders.add(parentInode);
104 return getFoldersTree (f);
105 }
106
107
112 public void closeFolderTree (long parentInode) {
113 openFolders.remove(parentInode);
114 }
115
116
117 @SuppressWarnings ("unchecked")
118 public List <Map <String , Object >> openFolderContent (long parentInode, String sortBy, boolean showArchived) {
119
120 String condition = "(working = " + DbConnectionFactory.getDBTrue();
121 if (showArchived) {
122 condition += ")";
123 } else {
124 condition += " and deleted = " + DbConnectionFactory.getDBFalse() + ")";
125 }
126
127 List <Map <String , Object >> returnList = new ArrayList <Map <String , Object >> ();
128
129 WebContext ctx = WebContextFactory.get();
130 User usr = getUser(ctx.getHttpServletRequest());
131 Role[] roles = RoleFactory.getAllRolesForUser(usr.getUserId()).toArray(new Role[0]);
132
133 Folder f = (Folder) InodeFactory.getInode(parentInode, Folder.class);
134 activeFolderInode = parentInode;
135
136 List <Folder> folders = InodeFactory.getChildrenClass(f, Folder.class);
137 for (Folder folder : folders) {
138 Map <String , Object > folderMap = folder.getMap();
139 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(folder, roles);
140 folderMap.put("permissions", permissions);
141 appendFolderProperties(folder, folderMap);
142 returnList.add(folderMap);
143 }
144 List <HTMLPage> pages = InodeFactory.getChildrenClassByCondition(f, HTMLPage.class, condition);
145 for (HTMLPage page : pages) {
146 Map <String , Object > pageMap = page.getMap();
147 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(page, roles);
148 pageMap.put("permissions", permissions);
149 returnList.add(pageMap);
150 }
151 List <File> files = InodeFactory.getChildrenClassByCondition(f, File.class, condition);
152 for (File file : files) {
153 Map <String , Object > fileMap = file.getMap();
154 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(file, roles);
155 fileMap.put("permissions", permissions);
156 returnList.add(fileMap);
157 }
158 List <Link> links = InodeFactory.getChildrenClassByCondition(f, Link.class, condition);
159 for (Link link : links) {
160 Map <String , Object > linkMap = link.getMap();
161 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(link, roles);
162 linkMap.put("permissions", permissions);
163 returnList.add(linkMap);
164 }
165
166 if (sortBy != null && UtilMethods.isSet(sortBy)) {
167 if (sortBy.equals(lastSortBy)) {
168 lastSortDirectionDesc = !lastSortDirectionDesc;
169 }
170 this.lastSortBy = sortBy;
171 }
172
173 WebAssetMapComparator comparator = new WebAssetMapComparator (lastSortBy, lastSortDirectionDesc);
174 Collections.sort(returnList, comparator);
175
176 return returnList;
177 }
178
179 @SuppressWarnings ("unchecked")
180 private List <Map > getFoldersTree (Inode parent) {
181 WebContext ctx = WebContextFactory.get();
182 User usr = getUser(ctx.getHttpServletRequest());
183 Role[] roles = RoleFactory.getAllRolesForUser(usr.getUserId()).toArray(new Role[0]);
184
185 ArrayList <Map > folders = new ArrayList <Map > ();
186 List <Folder> children = InodeFactory.getChildrenClass(parent, Folder.class, "name");
187 for (Folder f : children) {
188 Map <String , Object > folderMap = f.getMap();
189 if (openFolders.contains(f.getInode())) {
190 List <Map > childrenMaps = getFoldersTree (f);
191 folderMap.put("open", true);
192 folderMap.put("childrenFolders", childrenMaps);
193 } else {
194 folderMap.put("open", false);
195 }
196 if(f.getInode() == activeFolderInode)
197 folderMap.put("selected", true);
198 else
199 folderMap.put("selected", false);
200 appendFolderProperties(f, folderMap);
201
202 List <String > permissions = PermissionCache.getPermissionIdsByRolesFromCache(f, roles);
203 folderMap.put("permissions", permissions);
204
205 folders.add(folderMap);
206 }
207 return folders;
208 }
209
210 public Map <String , Object > renameFolder (long inode, String newName) {
211 HashMap <String , Object > result = new HashMap <String , Object > ();
212 Folder folder = (Folder) InodeFactory.getInode(inode, Folder.class);
213 result.put("lastName", folder.getName());
214 result.put("extension", "");
215 result.put("newName", newName);
216 result.put("inode", folder.getInode());
217 if (FolderFactory.renameFolder(folder, newName)) {
218 result.put("result", 0);
219 } else {
220 result.put("result", 1);
221 result.put("errorReason", "There is another folder that has the same name");
222 }
223 return result;
224 }
225
226 public boolean copyFolder(long inode, long newFolder) throws Exception {
228 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
229 User user = getUser(req);
230
231 Folder folder = (Folder) InodeFactory.getInode(inode, Folder.class);
232
233
235 if (!FolderFactory.existsFolder(newFolder)) {
236 Host parentHost = (Host) InodeFactory.getInode(newFolder,
237 Host.class);
238
239 if (!PermissionFactory.doesUserHavePermission(folder, Config.getIntProperty("PERMISSION_WRITE"), user) ||
240 !PermissionFactory.doesUserHavePermission(parentHost, Config.getIntProperty("PERMISSION_WRITE"), user))
241 throw new DotRuntimeException("The user doesn't have the required permissions.");
242
243 FolderFactory.copyFolder(folder, parentHost);
244 } else {
245 Folder parentFolder = (Folder) InodeFactory.getInode(newFolder,
246 Folder.class);
247
248 if (!PermissionFactory.doesUserHavePermission(folder, Config.getIntProperty("PERMISSION_WRITE"), user) ||
249 !PermissionFactory.doesUserHavePermission(parentFolder, Config.getIntProperty("PERMISSION_WRITE"), user))
250 throw new DotRuntimeException("The user doesn't have the required permissions.");
251
252 if (parentFolder.getInode() == folder.getInode()) {
253 return false;
255 }
256 if (FolderFactory.isChildFolder(parentFolder, folder)) {
257 return false;
259 }
260
261 FolderFactory.copyFolder(folder, parentFolder);
262 }
263 return true;
264 }
265
266 public boolean moveFolder(long inode, long newFolder) throws Exception {
268
269 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
270 User user = getUser(req);
271
272 Folder folder = (Folder) InodeFactory.getInode(inode, Folder.class);
273
274 if (!FolderFactory.existsFolder(newFolder)) {
275 Host parentHost = (Host) InodeFactory.getInode(newFolder,
276 Host.class);
277
278 if (!PermissionFactory.doesUserHavePermission(folder, Config.getIntProperty("PERMISSION_WRITE"), user) ||
279 !PermissionFactory.doesUserHavePermission(parentHost, Config.getIntProperty("PERMISSION_WRITE"), user))
280 throw new DotRuntimeException("The user doesn't have the required permissions.");
281
282 if (!FolderFactory.moveFolder(folder, parentHost)) {
283 return false;
285 }
286 } else {
287 Folder parentFolder = (Folder) InodeFactory.getInode(newFolder,
288 Folder.class);
289
290 if (!PermissionFactory.doesUserHavePermission(folder, Config.getIntProperty("PERMISSION_WRITE"), user) ||
291 !PermissionFactory.doesUserHavePermission(parentFolder, Config.getIntProperty("PERMISSION_WRITE"), user))
292 throw new DotRuntimeException("The user doesn't have the required permissions.");
293
294 if (parentFolder.getInode() == folder.getInode()) {
295 return false;
297 }
298 if (FolderFactory.isChildFolder(parentFolder, folder)) {
299 return false;
301 }
302 if (!FolderFactory.moveFolder(folder, parentFolder)) {
303 return false;
305 }
306 }
307 return true;
308 }
309
310 public Map <String , Object > renameFile (long inode, String newName) throws Exception {
311
312 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
313 User user = null;
314 try {
315 user = com.liferay.portal.util.PortalUtil.getUser(req);
316 } catch (Exception e) {
317 Logger.error(this, "Error trying to obtain the current liferay user from the request.", e);
318 throw new DotRuntimeException ("Error trying to obtain the current liferay user from the request.");
319 }
320
321 HashMap <String , Object > result = new HashMap <String , Object > ();
322 File file = (File) InodeFactory.getInode(inode, File.class);
323 result.put("lastName", file.getNameOnly());
324 result.put("extension", file.getExtension());
325 result.put("newName", newName);
326 result.put("inode", inode);
327 if (FileFactory.renameFile(file, newName, user)) {
328 result.put("result", 0);
329 } else {
330 result.put("result", 1);
331 if (file.isLocked())
332 result.put("errorReason", "The file is locked");
333 else
334 result.put("errorReason", "Another file with the same name already exists on this folder");
335 }
336 return result;
337 }
338
339 public boolean copyFile (long inode, long newFolder) throws Exception {
340
341 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
342 User user = getUser(req);
343
344 File file = (File) InodeFactory.getInode(inode, File.class);
345
346 Folder parent = (Folder) InodeFactory.getInode(newFolder, Folder.class);
348
349 if (!PermissionFactory.doesUserHavePermission(file, Config.getIntProperty("PERMISSION_WRITE"), user) ||
351 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
352 throw new DotRuntimeException("The user doesn't have the required permissions.");
353
354 FileFactory.copyFile(file, parent);
355
356 return true;
357
358 }
359
360 public boolean moveFile (long inode, long folder) throws Exception {
361 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
362 User user = getUser(req);
363
364 File file = (File) InodeFactory.getInode(inode, File.class);
365
366 Folder parent = (Folder) InodeFactory.getInode(folder, Folder.class);
368
369 if (!PermissionFactory.doesUserHavePermission(file, Config.getIntProperty("PERMISSION_WRITE"), user) ||
371 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
372 throw new DotRuntimeException("The user doesn't have the required permissions.");
373
374 return FileFactory.moveFile(file, parent);
375
376 }
377
378
379 public Map <String , Object > renameHTMLPage (long inode, String newName) throws Exception {
380
381 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
382 User user = getUser(req);
383
384 HashMap <String , Object > result = new HashMap <String , Object > ();
385 HTMLPage page = (HTMLPage) InodeFactory.getInode(inode, HTMLPage.class);
386 String pageURL = page.getPageUrl();
387 result.put("lastName", pageURL.substring(0, pageURL.lastIndexOf(".")));
388 result.put("extension", "dot");
389 result.put("newName", newName);
390 result.put("inode", inode);
391 if (HTMLPageFactory.renameHTMLPage(page, newName, user)) {
392 result.put("result", 0);
393 } else {
394 result.put("result", 1);
395 if (page.isLocked())
396 result.put("errorReason", "The page is locked");
397 else
398 result.put("errorReason", "Another page with the same name already exists on this folder");
399 }
400 return result;
401 }
402
403 public boolean copyHTMLPage (long inode, long newFolder) throws Exception {
404
405 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
406 User user = getUser(req);
407
408 HTMLPage page = (HTMLPage) InodeFactory.getInode(inode, HTMLPage.class);
409
410 Folder parent = (Folder) InodeFactory.getInode(newFolder, Folder.class);
412
413 if (!PermissionFactory.doesUserHavePermission(page, Config.getIntProperty("PERMISSION_WRITE"), user) ||
415 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
416 throw new DotRuntimeException("The user doesn't have the required permissions.");
417
418 HTMLPageFactory.copyHTMLPage(page, parent);
419
420 return true;
421
422 }
423
424 public boolean moveHTMLPage (long inode, long folder) throws Exception {
425
426 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
427 User user = getUser(req);
428
429 HTMLPage page = (HTMLPage) InodeFactory.getInode(inode, HTMLPage.class);
430
431 Folder parent = (Folder) InodeFactory.getInode(folder, Folder.class);
433
434 if (!PermissionFactory.doesUserHavePermission(page, Config.getIntProperty("PERMISSION_WRITE"), user) ||
436 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
437 throw new DotRuntimeException("The user doesn't have the required permissions.");
438
439 return HTMLPageFactory.moveHTMLPage(page, parent);
440
441 }
442
443 public Map <String , Object > renameLink (long inode, String newName) throws Exception {
444
445 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
446 User user = null;
447 try {
448 user = com.liferay.portal.util.PortalUtil.getUser(req);
449 } catch (Exception e) {
450 Logger.error(this, "Error trying to obtain the current liferay user from the request.", e);
451 throw new DotRuntimeException ("Error trying to obtain the current liferay user from the request.");
452 }
453
454 HashMap <String , Object > result = new HashMap <String , Object > ();
455 Link link = (Link) InodeFactory.getInode(inode, Link.class);
456 String oldName = link.getTitle();
457 result.put("lastName", oldName);
458 result.put("extension", "");
459 result.put("newName", newName);
460 result.put("inode", inode);
461 if (LinkFactory.renameLink(link, newName, user)) {
462 result.put("result", 0);
463 } else {
464 result.put("result", 1);
465 if (link.isLocked())
466 result.put("errorReason", "The link is locked");
467 else
468 result.put("errorReason", "Another link with the same name already exists on this folder");
469 }
470 return result;
471 }
472
473 public boolean copyLink (long inode, long newFolder) throws Exception {
474
475 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
476 User user = getUser(req);
477
478 Link link = (Link) InodeFactory.getInode(inode, Link.class);
479
480 Folder parent = (Folder) InodeFactory.getInode(newFolder, Folder.class);
482
483 if (!PermissionFactory.doesUserHavePermission(link, Config.getIntProperty("PERMISSION_WRITE"), user) ||
485 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
486 throw new DotRuntimeException("The user doesn't have the required permissions.");
487
488 LinkFactory.copyLink(link, parent);
489
490 return true;
491
492 }
493
494 public boolean moveLink (long inode, long folder) throws Exception {
495
496 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
497 User user = getUser(req);
498
499 Link link = (Link) InodeFactory.getInode(inode, Link.class);
500
501 Folder parent = (Folder) InodeFactory.getInode(folder, Folder.class);
503
504 if (!PermissionFactory.doesUserHavePermission(link, Config.getIntProperty("PERMISSION_WRITE"), user) ||
506 !PermissionFactory.doesUserHavePermission(parent, Config.getIntProperty("PERMISSION_WRITE"), user))
507 throw new DotRuntimeException("The user doesn't have the required permissions.");
508
509 return LinkFactory.moveLink(link, parent);
510
511 }
512
513 public boolean publishAsset (long inode) throws Exception {
514 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
515 User user = getUser(req);
516
517 Inode asset = (Inode) InodeFactory.getInode(inode, Inode.class);
518
519 if (!PermissionFactory.doesUserHavePermission(asset, Config.getIntProperty("PERMISSION_PUBLISH"), user))
520 throw new DotRuntimeException("The user doesn't have the required permissions.");
521
522 return PublishFactory.publishAsset(asset, req);
523 }
524
525 public boolean unPublishAsset (long inode) throws Exception {
526 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
527 User user = getUser(req);
528
529 WebAsset asset = (WebAsset) InodeFactory.getInode(inode, Inode.class);
530
531 Folder parent = (Folder)InodeFactory.getParentOfClass(asset, Folder.class);
532
533 if (!PermissionFactory.doesUserHavePermission(asset, Config.getIntProperty("PERMISSION_PUBLISH"), user))
534 throw new DotRuntimeException("The user doesn't have the required permissions.");
535
536 return WebAssetFactory.unPublishAsset(asset, user.getUserId(), parent);
537 }
538
539 public boolean archiveAsset (long inode) throws Exception {
540 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
541 User user = getUser(req);
542
543 WebAsset asset = (WebAsset) InodeFactory.getInode(inode, Inode.class);
544
545 if (!PermissionFactory.doesUserHavePermission(asset, Config.getIntProperty("PERMISSION_WRITE"), user))
546 throw new DotRuntimeException("The user doesn't have the required permissions.");
547
548 return WebAssetFactory.deleteAsset(asset, user.getUserId());
549 }
550
551 public boolean unArchiveAsset (long inode) throws Exception {
552 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
553 User user = getUser(req);
554
555 WebAsset asset = (WebAsset) InodeFactory.getInode(inode, Inode.class);
556
557
558 if (!PermissionFactory.doesUserHavePermission(asset, Config.getIntProperty("PERMISSION_WRITE"), user))
559 throw new DotRuntimeException("The user doesn't have the required permissions.");
560
561 WebAssetFactory.unDeleteAsset(asset);
562
563 return true;
564 }
565
566
567 public boolean unlockAsset (long inode) throws Exception {
568 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
569 User user = getUser(req);
570
571 WebAsset asset = (WebAsset) InodeFactory.getInode(inode, Inode.class);
572
573 if (!PermissionFactory.doesUserHavePermission(asset, Config.getIntProperty("PERMISSION_WRITE"), user))
574 throw new DotRuntimeException("The user doesn't have the required permissions.");
575
576 WebAssetFactory.unLockAsset(asset);
577 return true;
578 }
579
580 public Map <String , Object > changeAssetMenuOrder (long inode, int newValue) throws ActionException {
581
582 HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
583 User user = null;
584 try {
585 user = com.liferay.portal.util.PortalUtil.getUser(req);
586 } catch (Exception e) {
587 Logger.error(this, "Error trying to obtain the current liferay user from the request.", e);
588 throw new DotRuntimeException ("Error trying to obtain the current liferay user from the request.");
589 }
590
591 HashMap <String , Object > result = new HashMap <String , Object > ();
592 WebAsset asset = (WebAsset) InodeFactory.getInode(inode, Inode.class);
593 result.put("lastValue", asset.getSortOrder());
594 WebAssetFactory.changeAssetMenuOrder (asset, newValue, user);
595 result.put("result", 0);
596 return result;
597 }
598
599
600 private int getSubFoldersCount (Host parent) {
601 return InodeFactory.countChildrenOfClass(parent, Folder.class);
602 }
603
604 private void appendFolderProperties (Folder parent, Map <String , Object > folderMap) {
605 int subFolders = InodeFactory.countChildrenOfClass(parent, Folder.class);
606 int htmlPages = InodeFactory.countChildrenOfClass(parent, HTMLPage.class);
607 int files = InodeFactory.countChildrenOfClass(parent, File.class);
608 int links = InodeFactory.countChildrenOfClass(parent, Link.class);
609 folderMap.put("childrenFoldersCount", subFolders);
610 folderMap.put("childrenPagesCount", htmlPages);
611 folderMap.put("childrenLinksCount", files);
612 folderMap.put("childrenFilesCount", links);
613 folderMap.put("childrenCount", subFolders + htmlPages + files + links);
614 Inode parentInode = (Inode) InodeFactory.getParentOfClass(parent, Folder.class);
615 if (parentInode.getInode() == 0)
616 parentInode = (Inode) InodeFactory.getParentOfClass(parent, Host.class);
617 folderMap.put("parent", parentInode.getInode());
618 }
619
620 private User getUser(HttpServletRequest req) {
621
622 User user = null;
624 try {
625 user = com.liferay.portal.util.PortalUtil.getUser(req);
626 } catch (Exception e) {
627 Logger.error(this, "Error trying to obtain the current liferay user from the request.", e);
628 throw new DotRuntimeException ("Error trying to obtain the current liferay user from the request.");
629 }
630 return user;
631
632 }
633
634
635
636
637 }
638 |
Popular Tags |
Java API By Example, From Geeks To Geeks.