KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > dotmarketing > portlets > folders > factories > FolderFactory


1 package com.dotmarketing.portlets.folders.factories;
2
3 import java.net.URLDecoder JavaDoc;
4 import java.util.ArrayList JavaDoc;
5 import java.util.Comparator JavaDoc;
6 import java.util.HashMap JavaDoc;
7 import java.util.Hashtable JavaDoc;
8 import java.util.Iterator JavaDoc;
9 import java.util.List JavaDoc;
10 import java.util.Locale JavaDoc;
11 import java.util.Map JavaDoc;
12 import java.util.Stack JavaDoc;
13 import java.util.StringTokenizer JavaDoc;
14 import java.util.TimeZone JavaDoc;
15
16 import javax.portlet.ActionRequest;
17
18 import org.apache.oro.text.regex.Pattern;
19 import org.apache.oro.text.regex.Perl5Compiler;
20 import org.apache.oro.text.regex.Perl5Matcher;
21
22 import com.dotmarketing.beans.Host;
23 import com.dotmarketing.beans.Identifier;
24 import com.dotmarketing.beans.Inode;
25 import com.dotmarketing.beans.Permission;
26 import com.dotmarketing.beans.WebAsset;
27 import com.dotmarketing.cache.IdentifierCache;
28 import com.dotmarketing.cache.LiveCache;
29 import com.dotmarketing.cache.PermissionCache;
30 import com.dotmarketing.cache.WorkingCache;
31 import com.dotmarketing.db.DotConnect;
32 import com.dotmarketing.db.DotHibernate;
33 import com.dotmarketing.factories.HostFactory;
34 import com.dotmarketing.factories.IdentifierFactory;
35 import com.dotmarketing.factories.InodeFactory;
36 import com.dotmarketing.factories.PermissionFactory;
37 import com.dotmarketing.factories.WebAssetFactory;
38 import com.dotmarketing.menubuilders.RefreshMenus;
39 import com.dotmarketing.portlets.files.factories.FileFactory;
40 import com.dotmarketing.portlets.files.model.File;
41 import com.dotmarketing.portlets.folders.model.Folder;
42 import com.dotmarketing.portlets.htmlpages.factories.HTMLPageFactory;
43 import com.dotmarketing.portlets.htmlpages.model.HTMLPage;
44 import com.dotmarketing.portlets.links.factories.LinkFactory;
45 import com.dotmarketing.portlets.links.model.Link;
46 import com.dotmarketing.services.PageServices;
47 import com.dotmarketing.util.AssetsComparator;
48 import com.dotmarketing.util.Config;
49 import com.dotmarketing.util.Logger;
50 import com.dotmarketing.util.UtilMethods;
51 import com.liferay.portal.model.Role;
52
53 /**
54  *
55  * @author maria
56  */

57 public class FolderFactory {
58     private static int nodeId;
59     
60     private static java.text.DateFormat JavaDoc loginDateFormat;
61     
62     public static boolean existsFolder(String JavaDoc folderInode) {
63         DotConnect dc = new DotConnect();
64         dc.setSQL("select count(*) as count from folder where inode = ?");
65         dc.addParam(folderInode);
66         ArrayList JavaDoc results = dc.getResults();
67         if (((String JavaDoc) ((Map JavaDoc) results.get(0)).get("count")).equals("0"))
68             return false;
69         else
70             return true;
71     }
72
73     public static boolean existsFolder(long folderInode) {
74         return existsFolder(Long.toString(folderInode));
75     }
76     
77     public static Folder getFolderByInode(long folderInode)
78     {
79         Folder folder = (Folder) InodeFactory.getInode(folderInode,Folder.class);
80         return folder;
81     }
82     
83     @SuppressWarnings JavaDoc("unchecked")
84     public static java.util.List JavaDoc<Folder> getFoldersByParent(long pfolderOrHostId) {
85         
86         DotHibernate dh = new DotHibernate(Folder.class);
87         
88         String JavaDoc query = "SELECT {folder.*} from folder folder, inode folder_1_, tree tree where tree.parent = ? and tree.child = folder.inode and folder_1_.inode = folder.inode order by sort_order, name";
89         dh.setSQLQuery(query);
90         dh.setParam(pfolderOrHostId);
91         
92         return (java.util.List JavaDoc<Folder>) dh.list();
93     }
94     
95     public static java.util.List JavaDoc<Folder> getFoldersByParentSortByTitle(long pfolderOrHostId) {
96         
97         DotHibernate dh = new DotHibernate(Folder.class);
98         
99         String JavaDoc query = "SELECT {folder.*} from folder folder, inode folder_1_, tree tree where tree.parent = ? and tree.child = folder.inode and folder_1_.inode = folder.inode order by folder.title";
100         dh.setSQLQuery(query);
101         dh.setParam(pfolderOrHostId);
102         
103         return (java.util.List JavaDoc<Folder>) dh.list();
104     }
105     
106     public static java.util.List JavaDoc getFoldersByParentAndCondition(
107             long pfolderOrHostId, String JavaDoc condition) {
108         
109         DotHibernate dh = new DotHibernate(Folder.class);
110         
111         dh
112         .setSQLQuery("SELECT {folder.*} from folder folder, inode folder_1_, tree tree where tree.parent = ? and tree.child = folder.inode and folder_1_.inode = folder.inode and "
113                 + condition + " order by sort_order, name");
114         dh.setParam(pfolderOrHostId);
115         
116         return (java.util.List JavaDoc) dh.list();
117     }
118     
119     public static Folder getFolderByPath(String JavaDoc path, Host host) {
120         return getFolderByPath(path, host.getInode());
121     }
122     
123     public static Folder getFolderByPath(String JavaDoc path, long hostId) {
124         
125         // Normal path of execution, condition: the folder has the host attached
126
// as parent
127
DotHibernate dh = new DotHibernate(Folder.class);
128         dh
129         .setSQLQuery("select {folder.*} from folder, inode folder_1_, tree where path = ? and folder.inode = folder_1_.inode and tree.child = folder.inode and tree.parent = ?");
130         dh.setParam(path);
131         dh.setParam(hostId);
132         Folder f = (Folder) dh.load();
133         
134         if (f.getInode() > 0) {
135             return f;
136         }
137         
138         // Safe path, condition: the folder donīt have the host attached as
139
// parent
140
dh = new DotHibernate(Folder.class);
141         dh
142         .setSQLQuery("select {folder.*} from folder, inode folder_1_ where path = ? and folder.inode = folder_1_.inode");
143         dh.setParam(path);
144         Iterator JavaDoc foldersIt = dh.list().iterator();
145         
146         while (foldersIt.hasNext()) {
147             Folder folder = (Folder) foldersIt.next();
148             if (HostFactory.getParentHost(folder).getInode() == hostId)
149                 return folder;
150         }
151         
152         return new Folder();
153     }
154     
155     public static List JavaDoc getFolderTree(long hostId, String JavaDoc openNodes,
156             String JavaDoc view, String JavaDoc content, long structureInode, Locale JavaDoc locale,
157             TimeZone JavaDoc timeZone, Role[] roles, boolean isAdminUser) {
158         return getFolderTree(openNodes, view, content, structureInode, locale,
159                 timeZone, roles, isAdminUser);
160     }
161     
162     public static List JavaDoc getFolderTree(String JavaDoc openNodes, String JavaDoc view,
163             String JavaDoc content, long structureInode, Locale JavaDoc locale,
164             TimeZone JavaDoc timeZone, Role[] roles, boolean isAdminUser) {
165         
166         List JavaDoc<String JavaDoc> entryList = new ArrayList JavaDoc<String JavaDoc>();
167         
168         loginDateFormat = java.text.DateFormat.getDateTimeInstance(
169                 java.text.DateFormat.SHORT, java.text.DateFormat.SHORT, locale);
170         loginDateFormat.setTimeZone(timeZone);
171         
172         List JavaDoc hosts = HostFactory.getAllHosts();
173         Iterator JavaDoc it = hosts.iterator();
174         
175         nodeId = 0;
176         
177         while (it.hasNext()) {
178             
179             Host host = (Host) it.next();
180             
181             List JavaDoc<Folder> folders = getFoldersByParent(host.getInode());
182             
183             java.util.List JavaDoc permissions = PermissionCache
184             .getPermissionIdsByRolesFromCache(host, roles);
185             
186             StringBuffer JavaDoc entry = new StringBuffer JavaDoc();
187             entry.append((++nodeId) + "|0|");
188             if (it.hasNext())
189                 entry.append("1|");
190             else
191                 entry.append("0|");
192             
193             // String hostName = host.getHostname().length() > 21 ?
194
// host.getHostname().substring(0, 19) + "..." : host.getHostname();
195
String JavaDoc hostName = host.getHostname();
196             
197             entry.append(host.getInode() + "|" + hostName + "|0|0|"
198                     + folders.size() + "|");
199             if (openNodes.indexOf(Long.toString(host.getInode())) != -1) {
200                 entry.append("1|");
201             } else {
202                 entry.append("0|");
203             }
204             entry.append(" |0|0|0|0| |");
205             
206             if (permissions.contains(Config
207                     .getStringProperty("PERMISSION_READ")))
208                 entry.append("1|");
209             else
210                 entry.append("0|");
211             if (permissions.contains(Config
212                     .getStringProperty("PERMISSION_WRITE")))
213                 entry.append("1|");
214             else
215                 entry.append("0|");
216             if (permissions.contains(Config
217                     .getStringProperty("PERMISSION_PUBLISH")))
218                 entry.append("1|");
219             else
220                 entry.append("0|");
221             entry.append(host.getHostname() + ":/" + "|0");
222             
223             entryList.add(entry.toString());
224             
225             // decode the view in case it's encoded
226
try {
227                 if (view != null) {
228                     view = URLDecoder.decode(view, "UTF-8");
229                 }
230             } catch (Exception JavaDoc e) {
231             }
232             
233             if (openNodes.indexOf(Long.toString(host.getInode())) != -1) {
234                 entryList = createFolderList(folders, entryList, host
235                         .getInode(), nodeId, openNodes, view, content,
236                         structureInode, roles, isAdminUser);
237             }
238         }
239         
240         return entryList;
241     }
242     
243     public static List JavaDoc getEntriesTree(Folder mainFolder, String JavaDoc openNodes,
244             String JavaDoc view, String JavaDoc content, long structureInode, Locale JavaDoc locale,
245             TimeZone JavaDoc timeZone, Role[] roles, boolean isAdminUser) {
246         
247         Host host = HostFactory.getParentHost(mainFolder);
248         
249         List JavaDoc<String JavaDoc> entryList = new ArrayList JavaDoc<String JavaDoc>();
250         
251         loginDateFormat = java.text.DateFormat.getDateTimeInstance(
252                 java.text.DateFormat.SHORT, java.text.DateFormat.SHORT, locale);
253         loginDateFormat.setTimeZone(timeZone);
254         
255         List JavaDoc<Folder> folders = new ArrayList JavaDoc<Folder>();
256         folders.add(mainFolder);
257         
258         nodeId = 0;
259         
260         // decode the view in case it's encoded
261
try {
262             if (view != null) {
263                 view = URLDecoder.decode(view, "UTF-8");
264             }
265         } catch (Exception JavaDoc e) {
266         }
267         
268         entryList = createFolderList(folders, entryList, host.getInode(), 0,
269                 openNodes, view, content, structureInode, roles, isAdminUser);
270         
271         return entryList;
272     }
273     
274     private static List JavaDoc<String JavaDoc> createFolderList(List JavaDoc<Folder> folders,
275             List JavaDoc<String JavaDoc> entryList, long parentFolderId, int parentId,
276             String JavaDoc openNodes, String JavaDoc view, String JavaDoc content, long structureInode,
277             Role[] roles, boolean adminUser) {
278         
279         Logger.debug(FolderFactory.class, "createFolderList: parentFolderId = "
280                 + parentFolderId + ", parentId = " + parentId + "openNodes = "
281                 + openNodes + ", view = " + view + ", content = " + content
282                 + ", isAdmin = " + adminUser);
283         
284         java.util.Iterator JavaDoc itr = folders.iterator();
285         
286         while (itr.hasNext()) {
287             boolean readPermission = true;
288             Folder folder = (Folder) itr.next();
289             
290             StringBuffer JavaDoc permsb = new StringBuffer JavaDoc();
291             
292             java.util.List JavaDoc permissions = PermissionCache
293             .getPermissionIdsByRolesFromCache(folder, roles);
294             
295             if (permissions.contains(Config
296                     .getStringProperty("PERMISSION_READ"))) {
297                 // read permission
298
permsb.append("1").append("|");
299             } else {
300                 // read permission
301
permsb.append("0").append("|");
302                 
303                 if (!itr.hasNext()) {
304                     entryList = replaceEntryNext(entryList, parentId);
305                 }
306                 readPermission = false;
307             }
308             
309             if (readPermission) {
310                 if (permissions.contains(Config
311                         .getStringProperty("PERMISSION_WRITE"))) {
312                     // write permission
313
permsb.append("1").append("|");
314                 } else {
315                     // write permission
316
permsb.append("0").append("|");
317                 }
318                 
319                 if (permissions.contains(Config
320                         .getStringProperty("PERMISSION_PUBLISH"))) {
321                     // publish permission
322
permsb.append("1");
323                 } else {
324                     // publish permission
325
permsb.append("0");
326                 }
327                 
328                 String JavaDoc permStr = permsb.toString();
329                 
330                 StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
331                 
332                 sb.append(++nodeId).append("|");
333                 sb.append(parentId).append("|");
334                 
335                 if (!itr.hasNext()) {
336                     sb.append("1");
337                 } else {
338                     sb.append("0");
339                 }
340                 
341                 sb.append("|");
342                 sb.append(folder.getInode()).append("|");
343                 
344                 sb.append(UtilMethods.javaScriptify(folder.getName())).append(
345                 "|");
346                 
347                 // folder type == 9
348
sb.append("9").append("|");
349                 sb.append(parentFolderId).append("|");
350                 
351                 // gets folder children for this folder
352
folders = getFoldersByParent(folder.getInode());
353                 
354                 List JavaDoc files = null;
355                 List JavaDoc htmlpages = null;
356                 List JavaDoc links = null;
357                 
358                 int size = folders.size();
359                 
360                 if (content.indexOf("files") != -1) {
361                     files = FileFactory
362                     .getFileChildrenByCondition(folder, view);
363                     size += files.size();
364                 }
365                 
366                 if (content.indexOf("htmlpages") != -1) {
367                     htmlpages = HTMLPageFactory.getHTMLPageChildrenByCondition(
368                             folder, view);
369                     size += htmlpages.size();
370                 }
371                 
372                 if (content.indexOf("links") != -1) {
373                     links = LinkFactory
374                     .getLinkChildrenByCondition(folder, view);
375                     size += links.size();
376                 }
377                 
378                 sb.append(size).append("|");
379                 
380                 String JavaDoc folderPath = UtilMethods.javaScriptify(folder.getPath());
381                 String JavaDoc showOnMenu = (folder.isShowOnMenu()) ? "1" : "0";
382                 
383                 if (openNodes.indexOf(Long.toString(folder.getInode())) != -1) {
384                     
385                     Logger.debug(FolderFactory.class, "opened node: "
386                             + folder.getInode());
387                     
388                     // it's going to be open
389
sb.append("1").append("|");
390                     
391                     // misc text
392
sb.append(" ").append("|");
393                     
394                     // live
395
sb.append("0").append("|");
396                     
397                     // working
398
sb.append("0").append("|");
399                     
400                     // deleted
401
sb.append("0").append("|");
402                     
403                     // locked
404
sb.append("0").append("|");
405                     
406                     // mod_date
407
sb.append(" ").append("|");
408                     
409                     // permissions
410
sb.append(permStr).append("|");
411                     
412                     // folder path
413
sb.append(folderPath).append("|");
414                     
415                     // show on menu
416
sb.append(showOnMenu);
417                     
418                     entryList.add(sb.toString());
419                     
420                     // adds the files from this folder to the entry list
421
int childParentId = nodeId;
422                     
423                     // adds the files children to the entry list
424
entryList = createFolderList(folders, entryList, folder
425                             .getInode(), childParentId, openNodes, view,
426                             content, structureInode, roles, adminUser);
427                     
428                     int versionCount = 0;
429                     
430                     if (content.indexOf("files") != -1) {
431                         entryList = createEntryList(entryList, files, folder
432                                 .getInode(), childParentId, openNodes, roles,
433                                 "11", 1, folderPath, versionCount);
434                     }
435                     
436                     // add one for each content type in refresh view from
437
// view_folders.jsp
438
if (content.indexOf("htmlpages") != -1) {
439                         entryList = createEntryList(entryList, htmlpages,
440                                 folder.getInode(), childParentId, openNodes,
441                                 roles, "15", 1, folderPath, versionCount);
442                     }
443                     
444                     // add one for each content type in refresh view from
445
// view_folders.jsp
446
if (content.indexOf("links") != -1) {
447                         entryList = createEntryList(entryList, links, folder
448                                 .getInode(), childParentId, openNodes, roles,
449                                 "16", 1, folderPath, versionCount);
450                     }
451                     
452                     if (content.equals("allcontent")) {
453                         // files
454
files = FileFactory.getFileChildrenByCondition(folder,
455                                 view);
456                         entryList = createEntryList(entryList, files, folder
457                                 .getInode(), childParentId, openNodes, roles,
458                                 "11", 1, folderPath, versionCount);
459                         
460                         // htmlpages
461
htmlpages = HTMLPageFactory
462                         .getHTMLPageChildrenByCondition(folder, view);
463                         entryList = createEntryList(entryList, htmlpages,
464                                 folder.getInode(), childParentId, openNodes,
465                                 roles, "15", 1, folderPath, versionCount);
466                         
467                         // links
468
links = LinkFactory.getLinkChildrenByCondition(folder,
469                                 view);
470                         entryList = createEntryList(entryList, links, folder
471                                 .getInode(), childParentId, openNodes, roles,
472                                 "16", 1, folderPath, versionCount);
473                     }
474                 } else {
475                     // it's going to be closed
476
sb.append("0").append("|");
477                     
478                     // misc text
479
sb.append(" ").append("|");
480                     
481                     // live
482
sb.append("0").append("|");
483                     
484                     // working
485
sb.append("0").append("|");
486                     
487                     // deleted
488
sb.append("0").append("|");
489                     
490                     // locked
491
sb.append("0").append("|");
492                     
493                     // mod_date
494
sb.append(" ").append("|");
495                     
496                     // permissions
497
sb.append(permStr).append("|");
498                     
499                     // folder path
500
sb.append(folderPath).append("|");
501                     
502                     // show on menu
503
sb.append(showOnMenu);
504                     
505                     entryList.add(sb.toString());
506                 }
507             }
508         }
509         
510         return entryList;
511     }
512     
513     private static List JavaDoc<String JavaDoc> createEntryList(List JavaDoc<String JavaDoc> entryList,
514             List JavaDoc entries, long parentFolderId, int parentId, String JavaDoc openNodes,
515             Role[] roles, String JavaDoc entryType, long childrenSize,
516             String JavaDoc folderPath, int versionCount) {
517         
518         // go across the entries to know if there is a live or working version
519
java.util.Iterator JavaDoc itr = entries.iterator();
520         while (itr.hasNext()) {
521             WebAsset webasset = (WebAsset) itr.next();
522             if (webasset.isLive()) {
523                 versionCount--;
524             }
525         }
526         
527         itr = entries.iterator();
528         while (itr.hasNext()) {
529             WebAsset webasset = (WebAsset) itr.next();
530             
531             // Getting permissions
532
boolean readPermission = true;
533             
534             StringBuffer JavaDoc permsb = new StringBuffer JavaDoc();
535             
536             java.util.List JavaDoc permissionsList = PermissionCache
537             .getPermissionIdsByRolesFromCache(webasset, roles);
538             
539             if (permissionsList.contains(Config
540                     .getStringProperty("PERMISSION_READ"))) {
541                 // read permission
542
permsb.append("1").append("|");
543                 readPermission = true;
544             } else {
545                 // read permission
546
permsb.append("0").append("|");
547                 readPermission = false;
548             }
549             
550             if (readPermission) {
551                 if (permissionsList.contains(Config
552                         .getStringProperty("PERMISSION_WRITE"))) {
553                     // write permission
554
permsb.append("1").append("|");
555                 } else {
556                     // write permission
557
permsb.append("0").append("|");
558                 }
559                 
560                 if (permissionsList.contains(Config
561                         .getStringProperty("PERMISSION_PUBLISH"))) {
562                     // publish permission
563
permsb.append("1");
564                 } else {
565                     // publish permission
566
permsb.append("0");
567                 }
568                 
569                 String JavaDoc permissions = permsb.toString();
570                 
571                 String JavaDoc webassetVersion = "";
572                 if (!webasset.isWorking() && !webasset.isLive()
573                         && versionCount > 0) {
574                     webassetVersion = " (version " + versionCount + ") ";
575                     versionCount--;
576                 } else {
577                     // versionCount = 0;
578
}
579                 
580                 StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
581                 sb.append(++nodeId).append("|");
582                 sb.append(parentId).append("|");
583                 
584                 if (!itr.hasNext()) {
585                     sb.append("1");
586                 } else {
587                     sb.append("0");
588                 }
589                 
590                 sb.append("|");
591                 sb.append(webasset.getInode()).append("|");
592                 
593                 // it's a file
594
if (webasset instanceof com.dotmarketing.portlets.files.model.File) {
595                     com.dotmarketing.portlets.files.model.File file = (com.dotmarketing.portlets.files.model.File) webasset;
596                         sb.append(UtilMethods.javaScriptify(file.getFileName()) + webassetVersion).append("|");
597                     
598                 }
599                 // it's an html page
600
else if (webasset instanceof com.dotmarketing.portlets.htmlpages.model.HTMLPage) {
601                     com.dotmarketing.portlets.htmlpages.model.HTMLPage htmlpage = (com.dotmarketing.portlets.htmlpages.model.HTMLPage) webasset;
602                         sb.append(UtilMethods.javaScriptify(htmlpage.getPageUrl()) + webassetVersion).append("|");
603                     
604                 } else if (webasset instanceof com.dotmarketing.portlets.links.model.Link) {
605                     com.dotmarketing.portlets.links.model.Link link = (com.dotmarketing.portlets.links.model.Link) webasset;
606                     if (link.getUrl() != null) {
607                         int urlLength = 30;
608                         String JavaDoc workingUrl = "";
609                         // if the link is internal we dont show the host name
610
if (link.isInternal()) {
611                             workingUrl = link.getUrl();
612                             int idx = workingUrl.indexOf("/");
613                             if (idx > 0) {
614                                 workingUrl = workingUrl.substring(idx,
615                                         workingUrl.length());
616                             }
617                             workingUrl = UtilMethods.javaScriptify(workingUrl);
618                         } else {
619                             // if it's external we show the complete url
620
workingUrl = UtilMethods.javaScriptify(link
621                                     .getProtocal()
622                                     + link.getUrl());
623                         }
624                         
625                             sb.append(workingUrl + webassetVersion).append("|");
626                         
627                     } else {
628                         sb.append(link.getTitle()).append("|");
629                     }
630                 } else {
631                     if (webasset.getTitle().length() < 30) {
632                         sb.append(
633                                 UtilMethods.javaScriptify(webasset.getTitle())
634                                 + webassetVersion).append("|");
635                     } else {
636                         sb.append(
637                                 UtilMethods.javaScriptify(webasset.getTitle()
638                                         .substring(0, 30))
639                                         + webassetVersion).append("...|");
640                     }
641                 }
642                 
643                 // entry type (files=11,containers=12)
644
sb.append(entryType).append("|");
645                 sb.append(parentFolderId).append("|");
646                 
647                 sb.append(childrenSize).append("|");
648                 
649                 String JavaDoc showOnMenu = (webasset.isShowOnMenu()) ? "1" : "0";
650                 
651                 if (openNodes.indexOf(Long.toString(webasset.getInode())) != -1) {
652                     // gets versions and live for this working asset
653
entries = WebAssetFactory.getAssetVersionsandLive(webasset);
654                     
655                     // it's going to be open
656
sb.append("1").append("|");
657                     
658                     // if its a file append title instead of friendly name
659
// friendly name is used by portfolio to add description to
660
// images.
661
if (webasset instanceof com.dotmarketing.portlets.files.model.File) {
662                         if (webasset.getTitle().length() < 30) {
663                             sb.append(
664                                     UtilMethods.javaScriptify(webasset
665                                             .getTitle())
666                                             + webassetVersion).append("|");
667                         } else {
668                             sb.append(
669                                     UtilMethods.javaScriptify(webasset
670                                             .getTitle().substring(0, 30))
671                                             + webassetVersion).append("...|");
672                         }
673                     } else {
674                         // friendly name
675
if (webasset.getFriendlyName().length() < 30) {
676                             sb.append(
677                                     UtilMethods.javaScriptify(webasset
678                                             .getFriendlyName())
679                                             + webassetVersion).append("|");
680                         } else {
681                             sb.append(
682                                     UtilMethods
683                                     .javaScriptify(webasset
684                                             .getFriendlyName()
685                                             .substring(0, 30))
686                                             + webassetVersion).append("...|");
687                         }
688                     }
689                     
690                     // live
691
sb.append((webasset.isLive()) ? "1" : "0").append("|");
692                     
693                     // working
694
sb.append((webasset.isWorking()) ? "1" : "0").append("|");
695                     
696                     // deleted
697
sb.append((webasset.isDeleted()) ? "1" : "0").append("|");
698                     
699                     // locked
700
sb.append((webasset.isLocked()) ? "1" : "0").append("|");
701                     
702                     // mod_date
703
sb.append(loginDateFormat.format(webasset.getModDate()))
704                     .append("|");
705                     
706                     // permissions
707
sb.append(permissions).append("|");
708                     
709                     // folder path
710
sb.append(folderPath).append("|");
711                     
712                     // show on menu
713
sb.append(showOnMenu);
714                     
715                     entryList.add(sb.toString());
716                     
717                     // adds the files from this folder to the entry list
718
int childParentId = nodeId;
719                     
720                     entryList = createEntryList(entryList, entries, webasset
721                             .getInode(), childParentId, openNodes, roles,
722                             entryType, 0, folderPath, entries.size());
723                 } else {
724                     // it's going to be closed
725
sb.append("0").append("|");
726                     
727                     // if its a file append title instead of friendly name
728
// friendly name is used by portfolio to add description to
729
// images.
730
if (webasset instanceof com.dotmarketing.portlets.files.model.File) {
731                         if (webasset.getTitle().length() < 30) {
732                             sb.append(
733                                     UtilMethods.javaScriptify(webasset
734                                             .getTitle())
735                                             + webassetVersion).append("|");
736                         } else {
737                             sb.append(
738                                     UtilMethods.javaScriptify(webasset
739                                             .getTitle().substring(0, 30))
740                                             + webassetVersion).append("...|");
741                         }
742                     } else {
743                         String JavaDoc friendlyName = UtilMethods.isSet(webasset
744                                 .getFriendlyName()) ? webasset
745                                         .getFriendlyName() : "";
746                                         // friendly name
747
if (friendlyName.length() < 30) {
748                                             sb.append(
749                                                     UtilMethods.javaScriptify(friendlyName)
750                                                     + webassetVersion).append("|");
751                                         } else {
752                                             sb.append(
753                                                     UtilMethods.javaScriptify(friendlyName
754                                                             .substring(0, 30))
755                                                             + webassetVersion).append("...|");
756                                         }
757                     }
758                     
759                     // live
760
sb.append((webasset.isLive()) ? "1" : "0").append("|");
761                     
762                     // working
763
sb.append((webasset.isWorking()) ? "1" : "0").append("|");
764                     
765                     // deleted
766
sb.append((webasset.isDeleted()) ? "1" : "0").append("|");
767                     
768                     // locked
769
sb.append((webasset.isLocked()) ? "1" : "0").append("|");
770                     
771                     // mod_date
772
sb.append(loginDateFormat.format(webasset.getModDate()))
773                     .append("|");
774                     
775                     // permissions
776
sb.append(permissions).append("|");
777                     
778                     // folder path
779
sb.append(folderPath).append("|");
780                     
781                     // show on menu
782
sb.append(showOnMenu);
783                     
784                     entryList.add(sb.toString());
785                 }
786             }
787         }
788         
789         return entryList;
790     }
791     
792     @SuppressWarnings JavaDoc("unchecked")
793     public static List JavaDoc getFoldersAndEntriesByRoles(List JavaDoc folders, List JavaDoc entries,
794             Role[] roles, Class JavaDoc c, String JavaDoc condition) {
795         java.util.Iterator JavaDoc itr = folders.iterator();
796         
797         while (itr.hasNext()) {
798             Folder folder = (Folder) itr.next();
799             java.util.List JavaDoc permissions = PermissionCache
800             .getPermissionIdsByRolesFromCache(folder, roles);
801             
802             if (permissions.contains(Config
803                     .getStringProperty("PERMISSION_READ"))) {
804                 // read permission
805
List JavaDoc elements = InodeFactory.getChildrenClassByCondition(
806                         folder, c, condition);
807                 entries.addAll(elements);
808             }
809             
810             // gets folder children for this folder
811
folders = getFoldersByParent(folder.getInode());
812             entries = getFoldersAndEntriesByRoles(folders, entries, roles, c,
813                     condition);
814         }
815         
816         return entries;
817     }
818     
819     public static List JavaDoc getFoldersByParentByRolesAndSortBy(Folder folder,
820             Role[] roles) {
821         
822         List JavaDoc<Folder> entries = new ArrayList JavaDoc();
823         
824         List JavaDoc<Folder> elements = getFoldersByParentSortByTitle(folder.getInode());
825         for(Folder childFolder : elements){
826             List JavaDoc permissions = PermissionCache
827             .getPermissionIdsByRolesFromCache(childFolder, roles);
828             
829             if (permissions.contains(Config
830                     .getStringProperty("PERMISSION_READ"))) {
831                 // read permission
832

833                 entries.add(childFolder);
834             }
835         }
836         
837         
838         return entries;
839     }
840     
841     @SuppressWarnings JavaDoc("unchecked")
842     public static List JavaDoc getFoldersAndEntriesByRoles(List JavaDoc folders, List JavaDoc entries,
843             Role[] roles, Class JavaDoc c) {
844         java.util.Iterator JavaDoc itr = folders.iterator();
845         
846         while (itr.hasNext()) {
847             Folder folder = (Folder) itr.next();
848             java.util.List JavaDoc permissions = PermissionCache
849             .getPermissionIdsByRolesFromCache(folder, roles);
850             
851             if (permissions.contains(Config
852                     .getStringProperty("PERMISSION_READ"))) {
853                 // read permission
854
List JavaDoc elements = InodeFactory.getChildrenClass(folder, c);
855                 entries.addAll(elements);
856             }
857             
858             // gets folder children for this folder
859
folders = getFoldersByParent(folder.getInode());
860             entries = getFoldersAndEntriesByRoles(folders, entries, roles, c);
861         }
862         
863         return entries;
864     }
865     
866     private static List JavaDoc<String JavaDoc> replaceEntryNext(List JavaDoc<String JavaDoc> entryList,
867             int parentId) {
868         for (int k = entryList.size() - 1; k >= 0; k--) {
869             String JavaDoc entry = (String JavaDoc) entryList.get(k);
870             String JavaDoc[] entryArray = entry.split("\\|");
871             
872             if (entryArray[1].equals(String.valueOf(parentId))) {
873                 // found the closest sibling
874
entryArray[2] = "1";
875                 entry = UtilMethods.join(entryArray, "|");
876                 entry = entry.substring(0, entry.length() - 1);
877                 entryList.set(k, entry);
878                 
879                 return entryList;
880             }
881         }
882         
883         return entryList;
884     }
885     
886     
887     @SuppressWarnings JavaDoc("unchecked")
888     public static java.util.List JavaDoc getMenuItems(Inode inode) {
889         String JavaDoc condition = "show_on_menu="
890             + com.dotmarketing.db.DbConnectionFactory.getDBTrue();
891         
892         
893         // gets all subfolders
894
java.util.List JavaDoc folderListChildren = InodeFactory
895         .getChildrenClassByCondition(inode, Folder.class,
896                 condition);
897         
898         condition += (" and deleted =" + com.dotmarketing.db.DbConnectionFactory.getDBFalse() + " and live = " + com.dotmarketing.db.DbConnectionFactory.getDBTrue());
899         
900         // gets all links for this folder
901
java.util.List JavaDoc linksListSubChildren = InodeFactory
902         .getChildrenClassByCondition(inode, Link.class,
903                 condition);
904         
905         // gets all html pages for this folder
906
java.util.List JavaDoc htmlPagesSubListChildren = InodeFactory
907         .getChildrenClassByCondition(inode,
908                 HTMLPage.class, condition);
909         
910         // gets all files for this folder
911
java.util.List JavaDoc filesListSubChildren = InodeFactory
912         .getChildrenClassByCondition(inode, File.class,
913                 condition);
914         
915         // gets all subitems
916
java.util.List JavaDoc menuList = new java.util.ArrayList JavaDoc();
917         menuList.addAll(folderListChildren);
918         menuList.addAll(linksListSubChildren);
919         menuList.addAll(htmlPagesSubListChildren);
920         menuList.addAll(filesListSubChildren);
921         
922         Comparator JavaDoc comparator = new AssetsComparator();
923         java.util.Collections.sort(menuList, comparator);
924         
925         return menuList;
926     }
927     
928     @SuppressWarnings JavaDoc("unchecked")
929     public static java.util.List JavaDoc getFolderItems(Folder parentFolder,
930             String JavaDoc condition) {
931         condition += (" and deleted =" + com.dotmarketing.db.DbConnectionFactory.getDBFalse());
932         
933         // gets all links for this folder
934
java.util.List JavaDoc linksListSubChildren = InodeFactory
935         .getChildrenClassByCondition(parentFolder, Link.class,
936                 condition);
937         
938         // gets all html pages for this folder
939
java.util.List JavaDoc htmlPagesSubListChildren = InodeFactory
940         .getChildrenClassByCondition(parentFolder, HTMLPage.class,
941                 condition);
942         
943         // gets all files for this folder
944
java.util.List JavaDoc filesListSubChildren = InodeFactory
945         .getChildrenClassByCondition(parentFolder, File.class,
946                 condition);
947         
948         // gets all subitems
949
java.util.List JavaDoc menuList = new java.util.ArrayList JavaDoc();
950         menuList.addAll(linksListSubChildren);
951         menuList.addAll(htmlPagesSubListChildren);
952         menuList.addAll(filesListSubChildren);
953         
954         Comparator JavaDoc comparator = new AssetsComparator();
955         java.util.Collections.sort(menuList, comparator);
956         
957         return menuList;
958     }
959     
960     public static Folder createFolders(String JavaDoc path, long hostId,
961             ActionRequest req) {
962         Host host = HostFactory.getHost(hostId);
963         return createFolders(path, host, req);
964     }
965     
966     public static Folder createFolders(String JavaDoc path, Host host, ActionRequest req) {
967         DotHibernate.startTransaction();
968         
969         StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(path, "/");
970         StringBuffer JavaDoc sb = new StringBuffer JavaDoc("/");
971         
972         Folder parent = null;
973         
974         while (st.hasMoreTokens()) {
975             String JavaDoc name = st.nextToken();
976             sb.append(name + "/");
977             Folder f = getFolderByPath(sb.toString(), host);
978             if (f.getInode() == 0) {
979                 f.setName(name);
980                 f.setTitle(name);
981                 f.setPath(sb.toString());
982                 f.setShowOnMenu(false);
983                 f.setSortOrder(0);
984                 f.setHostInode(host.getInode());
985                 InodeFactory.saveInode(f);
986             }
987             if (parent == null) {
988                 host.addChild(f);
989                 InodeFactory.saveInode(host);
990             } else {
991                 parent.addChild(f);
992                 InodeFactory.saveInode(parent);
993             }
994             
995             // Copy parent folder Permissions
996
List JavaDoc list = null;
997             if (parent == null)
998                 list = PermissionFactory.getPermissions(host);
999             else
1000                list = PermissionFactory.getPermissions(parent);
1001            Iterator JavaDoc i = list.iterator();
1002            while (i.hasNext()) {
1003                Permission p = (Permission) i.next();
1004                Permission newPerm = new Permission();
1005                newPerm.setPermission(p.getPermission());
1006                newPerm.setRoleId(p.getRoleId());
1007                newPerm.setInode(f.getInode());
1008                
1009                PermissionFactory.savePermission(newPerm);
1010                
1011            }
1012            
1013            // Updating permissions cache
1014
PermissionCache.addToPermissionCache(f);
1015            
1016            parent = f;
1017            
1018        }
1019        DotHibernate.commitTransaction();
1020        return parent;
1021        
1022    }
1023    
1024    @SuppressWarnings JavaDoc("unchecked")
1025    private static void copyFolder(Folder folder, Inode destination,
1026            Hashtable JavaDoc copiedObjects) {
1027        
1028        if (copiedObjects == null)
1029            copiedObjects = new Hashtable JavaDoc();
1030        
1031        boolean rename = false;
1032        if (destination instanceof Folder) {
1033            rename = FolderFactory.folderContains(folder.getName(),
1034                    (Folder) destination);
1035        } else {
1036            rename = HostFactory.hostContains(folder.getName(),
1037                    (Host) destination);
1038        }
1039        
1040        Folder newFolder = new Folder();
1041        newFolder.copy(folder);
1042        newFolder.setName(folder.getName());
1043        while(rename) {
1044            newFolder.setName(newFolder.getName() + "_copy");
1045            if (destination instanceof Folder) {
1046                rename = FolderFactory.folderContains(newFolder.getName(),
1047                        (Folder) destination);
1048            } else {
1049                rename = HostFactory.hostContains(newFolder.getName(),
1050                        (Host) destination);
1051            }
1052        }
1053        
1054        
1055        if (destination instanceof Folder) {
1056            newFolder.setPath(((Folder) destination).getPath()
1057                    + newFolder.getName() + "/");
1058            newFolder.setHostInode(((Folder) destination).getHostInode());
1059        } else {
1060            newFolder.setPath("/" + newFolder.getName() + "/");
1061            newFolder.setHostInode(((Host) destination).getInode());
1062        }
1063        InodeFactory.saveInode(newFolder);
1064        destination.addChild(newFolder);
1065        
1066        // Copying folder permissions
1067
PermissionFactory.copyPermissions(folder, newFolder);
1068        
1069        // Copying children html pages
1070
Map JavaDoc<Long JavaDoc, HTMLPage[]> pagesCopied;
1071        if (copiedObjects.get("HTMLPages") == null) {
1072            pagesCopied = new HashMap JavaDoc<Long JavaDoc, HTMLPage[]>();
1073            copiedObjects.put("HTMLPages", pagesCopied);
1074        } else {
1075            pagesCopied = (Map JavaDoc<Long JavaDoc, HTMLPage[]>) copiedObjects
1076            .get("HTMLPages");
1077        }
1078        
1079        List JavaDoc<HTMLPage> pages = InodeFactory.getChildrenClass(folder,
1080                HTMLPage.class);
1081        for (HTMLPage page : pages) {
1082            if (page.isWorking()) {
1083                HTMLPage newPage = HTMLPageFactory
1084                .copyHTMLPage(page, newFolder);
1085                // Saving copied pages to update template - pages relationships
1086
// later
1087
pagesCopied.put(page.getInode(),
1088                        new HTMLPage[] { page, newPage });
1089            }
1090        }
1091        
1092        // Copying Files
1093
Map JavaDoc<Long JavaDoc, File[]> filesCopied;
1094        if (copiedObjects.get("Files") == null) {
1095            filesCopied = new HashMap JavaDoc<Long JavaDoc, File[]>();
1096            copiedObjects.put("Files", filesCopied);
1097        } else {
1098            filesCopied = (Map JavaDoc<Long JavaDoc, File[]>) copiedObjects.get("Files");
1099        }
1100        
1101        List JavaDoc<File> files = InodeFactory.getChildrenClass(folder, File.class);
1102        for (File file : files) {
1103            if (file.isWorking()) {
1104                File newFile = FileFactory.copyFile(file, newFolder);
1105                // Saving copied pages to update template - pages relationships
1106
// later
1107
filesCopied.put(file.getInode(), new File[] { file, newFile });
1108            }
1109        }
1110        
1111        // Copying links
1112
Map JavaDoc<Long JavaDoc, Link[]> linksCopied;
1113        if (copiedObjects.get("Links") == null) {
1114            linksCopied = new HashMap JavaDoc<Long JavaDoc, Link[]>();
1115            copiedObjects.put("Links", linksCopied);
1116        } else {
1117            linksCopied = (Map JavaDoc<Long JavaDoc, Link[]>) copiedObjects.get("Links");
1118        }
1119        
1120        List JavaDoc<Link> links = InodeFactory.getChildrenClass(folder, Link.class);
1121        for (Link link : links) {
1122            if (link.isWorking()) {
1123                Link newLink = LinkFactory.copyLink(link, newFolder);
1124                // Saving copied pages to update template - pages relationships
1125
// later
1126
linksCopied.put(link.getInode(), new Link[] { link, newLink });
1127            }
1128        }
1129        
1130        // Copying Inner Folders
1131
List JavaDoc<Folder> childrenFolder = InodeFactory.getChildrenClass(folder,
1132                Folder.class);
1133        for (Folder childFolder : childrenFolder) {
1134            copyFolder(childFolder, newFolder, copiedObjects);
1135        }
1136        
1137    }
1138    
1139    public static void copyFolder(Folder folder, Host destination) {
1140        copyFolder(folder, (Inode) destination, null);
1141    }
1142    
1143    public static void copyFolder(Folder folder, Folder destination) {
1144        copyFolder(folder, (Inode) destination, null);
1145    }
1146    
1147    @SuppressWarnings JavaDoc("unchecked")
1148    private static boolean folderContains(String JavaDoc name, Folder destination) {
1149        List JavaDoc<Folder> children = InodeFactory.getChildrenClass(destination,
1150                Folder.class);
1151        for (Folder folder : children) {
1152            if (folder.getName().equals(name))
1153                return true;
1154        }
1155        return false;
1156    }
1157    
1158    @SuppressWarnings JavaDoc("unchecked")
1159    private static boolean moveFolder(Folder folder, Inode destination) {
1160        boolean contains = false;
1161        if (destination instanceof Folder) {
1162            contains = FolderFactory.folderContains(folder.getName(),
1163                    (Folder) destination);
1164        } else {
1165            contains = HostFactory.hostContains(folder.getName(),
1166                    (Host) destination);
1167        }
1168        if (contains) return false;
1169        
1170        //removing from current parent
1171
Folder currentParentFolder = (Folder) InodeFactory.getParentOfClass(folder, Folder.class);
1172        if (currentParentFolder.getInode() > 0) {
1173            currentParentFolder.deleteChild(folder);
1174        } else {
1175            Host currentParentHost = (Host) InodeFactory.getParentOfClass(folder, Host.class);
1176            currentParentHost.deleteChild(folder);
1177        }
1178        destination.addChild(folder);
1179        
1180        //Setting the new host inode and folder path
1181
if (destination instanceof Host) {
1182            folder.setPath("/" + folder.getName() + "/");
1183            folder.setHostInode(destination.getInode());
1184        } else if (destination instanceof Folder) {
1185            folder.setPath(((Folder) destination).getPath() + folder.getName() + "/");
1186            folder.setHostInode(((Folder)destination).getHostInode());
1187        }
1188        InodeFactory.saveInode(folder);
1189        
1190        updateMovedFolderAssets (folder);
1191        //### RECURSIVE CALL ###
1192
moveRecursiveFolders(folder);
1193        //### END RECURSIVE CALL ###
1194

1195        if (folder.isShowOnMenu()) {
1196            //existing folder with different show on menu ... need to regenerate menu
1197
RefreshMenus.deleteMenus();
1198        }
1199
1200        return true;
1201    }
1202    
1203    /***
1204     * This methos update recursively the inner folders of the specified folder
1205     * @param folder
1206     */

1207    private static void moveRecursiveFolders(Folder folder)
1208    {
1209        Stack JavaDoc<Folder> innerFolders = new Stack JavaDoc<Folder>();
1210        innerFolders.addAll((List JavaDoc<Folder>)InodeFactory.getChildrenClass(folder, Folder.class));
1211        
1212        while (!innerFolders.empty()) {
1213            Folder nextFolder = innerFolders.pop();
1214            
1215            nextFolder.setPath(folder.getPath() + nextFolder.getName() + "/");
1216            nextFolder.setHostInode(folder.getHostInode());
1217            InodeFactory.saveInode(nextFolder);
1218            
1219            updateMovedFolderAssets (nextFolder);
1220            moveRecursiveFolders(nextFolder);
1221        }
1222    }
1223    
1224    /**
1225     * this method updates the asset info for the new paths
1226     * @param theFolder the folder moved
1227     */

1228    @SuppressWarnings JavaDoc("unchecked")
1229    private static void updateMovedFolderAssets (Folder theFolder) {
1230        List JavaDoc<HTMLPage> htmlPages = InodeFactory.getChildrenClass(theFolder, HTMLPage.class);
1231        for (HTMLPage page: htmlPages) {
1232            Identifier identifier = IdentifierFactory.getIdentifierByInode(page);
1233            
1234            if (page.isWorking()) {
1235                //updating caches
1236
WorkingCache.removeAssetFromCache(page);
1237                IdentifierCache.removeAssetFromIdCache(page);
1238            }
1239            
1240            if (page.isLive()) {
1241                LiveCache.removeAssetFromCache(page);
1242            }
1243            
1244            if (page.isWorking()) {
1245                //gets identifier for this webasset and changes the uri and
1246
// persists it
1247
Host newHost = HostFactory.getParentHost(theFolder);
1248                identifier.setHostInode(newHost.getInode());
1249                identifier.setURI(page.getURI(theFolder));
1250                InodeFactory.saveInode(identifier);
1251            }
1252            
1253            //Add to Preview and Live Cache
1254
if (page.isLive()) {
1255                LiveCache.addToLiveAssetToCache(page);
1256            }
1257            if (page.isWorking()) {
1258                WorkingCache.addToWorkingAssetToCache(page);
1259                IdentifierCache.addAssetToIdentifierCache(page);
1260            }
1261            
1262            //republishes the page to reset the VTL_SERVLETURI variable
1263
if (page.isLive()) {
1264                PageServices.publishPageToFile(page);
1265            }
1266            
1267        }
1268        
1269        List JavaDoc<File> files = InodeFactory.getChildrenClass(theFolder, File.class);
1270        for (File file: files) {
1271            Identifier identifier = IdentifierFactory.getIdentifierByInode(file);
1272            
1273            //assets cache
1274
if (file.isLive())
1275                LiveCache.removeAssetFromCache(file);
1276            
1277            if (file.isWorking())
1278                WorkingCache.removeAssetFromCache(file);
1279            
1280            if (file.isWorking()) {
1281                //gets identifier for this webasset and changes the uri and
1282
// persists it
1283
Host newHost = HostFactory.getParentHost(theFolder);
1284                identifier.setHostInode(newHost.getInode());
1285                identifier.setURI(file.getURI(theFolder));
1286                InodeFactory.saveInode(identifier);
1287            }
1288            
1289            //Add to Preview and Live Cache
1290
if (file.isLive()) {
1291                LiveCache.addToLiveAssetToCache(file);
1292            }
1293            if (file.isWorking())
1294                WorkingCache.addToWorkingAssetToCache(file);
1295            
1296        }
1297        
1298        List JavaDoc<Link> links = InodeFactory.getChildrenClass(theFolder, Link.class);
1299        for (Link link: links) {
1300            if (link.isWorking()) {
1301                
1302                Identifier identifier = IdentifierFactory.getIdentifierByInode(link);
1303                
1304                // gets identifier for this webasset and changes the uri and
1305
// persists it
1306
Host newHost = HostFactory.getParentHost(theFolder);
1307                identifier.setHostInode(newHost.getInode());
1308                identifier.setURI(link.getURI(theFolder));
1309                InodeFactory.saveInode(identifier);
1310            }
1311            
1312        }
1313        
1314    }
1315    
1316    public static boolean moveFolder(Folder folder, Folder destination) {
1317        return moveFolder(folder, (Inode) destination);
1318    }
1319    
1320    public static boolean moveFolder(Folder folder, Host destination) {
1321        return moveFolder(folder, (Inode) destination);
1322    }
1323    
1324    /**
1325     * Checks if folder1 is child of folder2
1326     * @param folder1
1327     * @param folder2
1328     * @return
1329     */

1330    public static boolean isChildFolder(Folder folder1, Folder folder2) {
1331        Folder parentFolder = (Folder) InodeFactory.getParentOfClass(folder1, Folder.class);
1332        if (parentFolder.getInode() == 0)
1333            return false;
1334        else {
1335            if (parentFolder.getInode() == folder2.getInode()) {
1336                return true;
1337            }
1338            return isChildFolder (parentFolder, folder2);
1339        }
1340    }
1341    
1342    public static boolean renameFolder(long folderInode,String JavaDoc newName)
1343    {
1344        Folder folder = getFolderByInode(folderInode);
1345        return renameFolder(folder,newName);
1346    }
1347    
1348    @SuppressWarnings JavaDoc("unchecked")
1349    public static boolean renameFolder(Folder folder,String JavaDoc newName)
1350    {
1351        try
1352        {
1353            Inode parent = (Inode)InodeFactory.getParentOfClass(folder, Folder.class);
1354            if (parent.getInode () == 0)
1355                parent = (Inode)InodeFactory.getParentOfClass(folder, Host.class);
1356            
1357            List JavaDoc<Folder> children = InodeFactory.getChildrenClass(parent, Folder.class);
1358            for (Folder child : children) {
1359                if (child.getInode() != folder.getInode() && child.getName().equals(newName))
1360                    return false;
1361            }
1362            
1363            String JavaDoc originalName = folder.getName();
1364            int folderLevel = folderLevel(folder);
1365            //Rename de folder
1366
folder.setName(newName);
1367            InodeFactory.saveInode(folder);
1368            
1369            //Change the URI of the internal pages, files and links
1370
renameInternalFiles(folder,originalName,newName,folderLevel);
1371            
1372            //Clean the caches
1373
IdentifierCache.clearCache();
1374            PermissionCache.clearCache();
1375            
1376            //return successful
1377
return true;
1378        }
1379        catch(Exception JavaDoc ex)
1380        {
1381            String JavaDoc message = ex.toString();
1382            Logger.warn(FolderFactory.class,message);
1383            return false;
1384        }
1385    }
1386    
1387    private static void renameInternalFiles(Folder folder,String JavaDoc originalName,String JavaDoc newName,int folderLevel)
1388    {
1389        changePathByFolder(folder,originalName,newName,folderLevel);
1390        
1391        //Get the HTMLPages
1392
List JavaDoc<HTMLPage> pages = InodeFactory.getChildrenClass(folder,HTMLPage.class);
1393        for(HTMLPage page : pages)
1394        {
1395            changeURIByAsset(page,originalName,newName,folderLevel);
1396        }
1397        
1398        //Get the Files
1399
List JavaDoc<File> files = InodeFactory.getChildrenClass(folder,File.class);
1400        for(File file : files)
1401        {
1402            changeURIByAsset(file,originalName,newName,folderLevel);
1403        }
1404        
1405        //Get the Links
1406
List JavaDoc<Link> links = InodeFactory.getChildrenClass(folder,Link.class);
1407        for(Link link : links)
1408        {
1409            changeURIByAsset(link,originalName,newName,folderLevel);
1410        }
1411        
1412        //Get the Folders for recursion
1413
List JavaDoc<Folder> folders = InodeFactory.getChildrenClass(folder,Folder.class);
1414        for(Folder internalFolder : folders)
1415        {
1416            renameInternalFiles(internalFolder,originalName,newName,folderLevel);
1417        }
1418    }
1419    
1420    private static void changeURIByAsset(Inode inode,String JavaDoc originalName,String JavaDoc newName,int folderLevel)
1421    {
1422        Identifier identifier = IdentifierFactory.getIdentifierByInode(inode);
1423        String JavaDoc URI = identifier.getURI();
1424        URI = renameByFolderLevel(URI,originalName,newName,folderLevel);
1425        identifier.setURI(URI);
1426        InodeFactory.saveInode(identifier);
1427    }
1428    
1429    private static void changePathByFolder(Folder folder,String JavaDoc originalName,String JavaDoc newName,int folderLevel)
1430    {
1431        String JavaDoc path = folder.getPath();
1432        path = renameByFolderLevel(path,originalName,newName,folderLevel);
1433        folder.setPath(path);
1434        InodeFactory.saveInode(folder);
1435    }
1436    
1437    private static int folderLevel(Folder folder)
1438    {
1439        int folderLevel = 1;
1440        Folder parentFolder = (Folder) InodeFactory.getParentOfClass(folder,Folder.class);
1441        while (parentFolder.getInode() != 0)
1442        {
1443            folderLevel++;
1444            parentFolder = (Folder) InodeFactory.getParentOfClass(parentFolder,Folder.class);
1445        }
1446        return folderLevel;
1447    }
1448    
1449    private static String JavaDoc renameByFolderLevel(String JavaDoc path,String JavaDoc originalName,String JavaDoc newName,int folderLevel)
1450    {
1451        String JavaDoc URIInitial;
1452        String JavaDoc URIReplace;
1453        String JavaDoc URIFinal;
1454        
1455        int initialCharacter = -1;
1456        int finalCharacter = -1;
1457        for(int i = 0;i < folderLevel;i++)
1458        {
1459            initialCharacter = path.indexOf("/",initialCharacter + 1);
1460        }
1461        finalCharacter = path.indexOf("/",initialCharacter + 1);
1462        
1463        //Split the URI
1464
URIInitial = path.substring(0,initialCharacter + 1);
1465        URIReplace = path.substring(initialCharacter + 1,finalCharacter);
1466        URIFinal = path.substring(finalCharacter);
1467        
1468        URIReplace = URIReplace.replace(originalName,newName);
1469        return URIInitial + URIReplace + URIFinal;
1470    }
1471    
1472    
1473    public static boolean matchFilter(Folder folder,String JavaDoc fileName)
1474    {
1475        //return value
1476
Perl5Matcher p5m = new Perl5Matcher();
1477        Perl5Compiler p5c = new Perl5Compiler();
1478        boolean match = false;
1479        try
1480        {
1481            //Obtain the filters
1482
String JavaDoc filesMasks = folder.getFilesMasks();
1483            filesMasks = (filesMasks != null ? filesMasks.trim() : filesMasks);
1484            
1485            if (UtilMethods.isSet(filesMasks))
1486            {
1487                String JavaDoc[] filesMasksArray = filesMasks.split(",");
1488                int length = filesMasksArray.length;
1489                
1490                //Try to match de filters
1491
for(int i = 0; i < length;i++)
1492                {
1493                    String JavaDoc regex = filesMasksArray[i];
1494                    regex = regex.replace(".","\\.");
1495                    regex = regex.replace("*",".*");
1496                    regex = "^" + regex.trim() + "$";
1497                    Pattern pattern = p5c.compile(regex,Perl5Compiler.CASE_INSENSITIVE_MASK);
1498                    match = match || p5m.matches(fileName,pattern);
1499                    if(match)
1500                    {
1501                        break;
1502                    }
1503                }
1504            }
1505            else
1506            {
1507                match = true;
1508            }
1509        }
1510        catch(Exception JavaDoc ex)
1511        {
1512            Logger.debug(FolderFactory.class,ex.toString());
1513        }
1514        return match;
1515    }
1516}
1517
Popular Tags