1 19 20 package org.openharmonise.dav.server.managers; 21 22 23 import java.io.*; 24 import java.net.*; 25 import java.util.*; 26 import java.util.logging.*; 27 28 import javax.xml.parsers.DocumentBuilderFactory ; 29 30 import org.openharmonise.commons.dsi.AbstractDataStoreInterface; 31 import org.openharmonise.commons.net.MimeTypeMapping; 32 import org.openharmonise.commons.xml.XMLUtils; 33 import org.openharmonise.commons.xml.namespace.NamespaceType; 34 import org.openharmonise.dav.server.adapters.WebPageResourceAdapter; 35 import org.openharmonise.dav.server.apm.*; 36 import org.openharmonise.dav.server.utils.*; 37 import org.openharmonise.rm.*; 38 import org.openharmonise.rm.config.ConfigSettings; 39 import org.openharmonise.rm.dsi.DataStoreInterfaceFactory; 40 import org.openharmonise.rm.metadata.*; 41 import org.openharmonise.rm.resources.*; 42 import org.openharmonise.rm.resources.content.*; 43 import org.openharmonise.rm.resources.lifecycle.*; 44 import org.openharmonise.rm.resources.lifecycle.Status; 45 import org.openharmonise.rm.resources.metadata.properties.*; 46 import org.openharmonise.rm.resources.metadata.properties.ranges.*; 47 import org.openharmonise.rm.resources.metadata.values.Value; 48 import org.openharmonise.rm.resources.publishing.WebPage; 49 import org.openharmonise.rm.resources.users.User; 50 import org.openharmonise.rm.resources.xml.*; 51 import org.openharmonise.rm.security.authorization.*; 52 import org.w3c.dom.*; 53 54 import com.ibm.webdav.*; 55 import com.ibm.webdav.impl.*; 56 import com.ibm.webdav.protocol.http.*; 57 58 65 71 public class HarmoniseNamespaceManager 72 implements com.ibm.webdav.impl.NamespaceManager { 73 public static final String TAG_AFTER = "after"; 74 public static final String TAG_BEFORE = "before"; 75 public static final String TAG_LAST = "last"; 76 public static final String TAG_FIRST = "first"; 77 public static final String TAG_POSITION = "position"; 78 public static final String TAG_SEGMENT = "segment"; 79 public static final String TAG_ORDER_MEMBER = "order-member"; 80 private static final int bufferSize = 8192; 81 protected AuxillaryProcessManager m_auxillary = null; 82 private static final String PNAME_WEBDAV_APM = "WEBDAV_APM"; 83 84 private boolean m_bIsArchived = false; 85 protected ResourceImpl m_resource = null; 86 protected AbstractChildObject m_child = null; 87 private OutputStream m_openedOutputStream = null; 88 protected AbstractDataStoreInterface m_dsi = null; 89 static private List STD_ALLOWED_METHODS = new Vector(); 90 static private List VIRTUAL_DIR_ALLOWED_METHODS = new Vector(); 91 static private List ARCHIVE_ALLOWED_METHODS = new Vector(); 92 static private Map DAV_HARMONISE_COMMAND_MAPPING = new Hashtable(); 93 94 private static Logger m_logger = Logger.getLogger(HarmoniseNamespaceManager.class.getName()); 95 96 static { 97 STD_ALLOWED_METHODS.add("PUT"); 98 STD_ALLOWED_METHODS.add("GET"); 99 STD_ALLOWED_METHODS.add("PROPFIND"); 100 STD_ALLOWED_METHODS.add("PROPPATCH"); 101 STD_ALLOWED_METHODS.add("OPTIONS"); 102 STD_ALLOWED_METHODS.add("SEARCH"); 103 STD_ALLOWED_METHODS.add("COPY"); 104 STD_ALLOWED_METHODS.add("DELETE"); 105 STD_ALLOWED_METHODS.add("MOVE"); 106 STD_ALLOWED_METHODS.add("BIND"); 107 STD_ALLOWED_METHODS.add("HEAD"); 108 STD_ALLOWED_METHODS.add("LOCK"); 109 STD_ALLOWED_METHODS.add("UNLOCK"); 110 111 VIRTUAL_DIR_ALLOWED_METHODS.add("PROPFIND"); 112 VIRTUAL_DIR_ALLOWED_METHODS.add("OPTIONS"); 113 VIRTUAL_DIR_ALLOWED_METHODS.add("SEARCH"); 114 115 ARCHIVE_ALLOWED_METHODS.addAll(VIRTUAL_DIR_ALLOWED_METHODS); 116 ARCHIVE_ALLOWED_METHODS.add("GET"); 117 118 DAV_HARMONISE_COMMAND_MAPPING.put("PUT", "Save"); 119 DAV_HARMONISE_COMMAND_MAPPING.put("PROPPATCH", "Save"); 120 DAV_HARMONISE_COMMAND_MAPPING.put("COPY", "Save"); 121 DAV_HARMONISE_COMMAND_MAPPING.put("MOVE", "Save"); 122 DAV_HARMONISE_COMMAND_MAPPING.put("MKCOL", "Save"); 123 DAV_HARMONISE_COMMAND_MAPPING.put("BIND", "Save"); 124 DAV_HARMONISE_COMMAND_MAPPING.put("LOCK", "Lock"); 125 DAV_HARMONISE_COMMAND_MAPPING.put("UNLOCK", "Unlock"); 126 DAV_HARMONISE_COMMAND_MAPPING.put("GET", "View"); 127 DAV_HARMONISE_COMMAND_MAPPING.put("PROPFIND", "View"); 128 DAV_HARMONISE_COMMAND_MAPPING.put("DELETE", "Archive"); 129 DAV_HARMONISE_COMMAND_MAPPING.put("CHECKIN", "ChangeStatus"); 130 DAV_HARMONISE_COMMAND_MAPPING.put("VERSION-CONTROL", "ChangeStatus"); 131 DAV_HARMONISE_COMMAND_MAPPING.put("CHECKOUT", "Save"); 132 } 133 134 137 public HarmoniseNamespaceManager() { 138 } 139 140 143 public HarmoniseNamespaceManager(ResourceImpl resource) { 144 initialize(resource); 145 } 146 147 public void closeContentsOutputStream() throws WebDAVException { 148 closeContentsOutputStream(null); 149 } 150 151 154 public void closeContentsOutputStream(String sContentType) 155 throws WebDAVException { 156 157 if(m_logger.isLoggable(Level.FINE)) { 158 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "Closing output stream"); 159 } 160 161 162 if (m_openedOutputStream == null) { 164 throw new WebDAVException( 165 WebDAVStatus.SC_BAD_REQUEST, 166 "No output stream is opened"); 167 } 168 169 try { 170 m_openedOutputStream.close(); 171 } catch (WebDAVException exc) { 172 throw exc; 173 } catch (java.io.IOException exc) { 174 throw new WebDAVException( 175 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 176 "IO Error"); 177 } 178 179 try { 180 String contentType = sContentType; 181 182 if (contentType == null) { 183 contentType = 184 m_resource.getContext().getRequestContext().contentType(); 185 } 186 187 String fileName = HarmoniseNameResolver.getFilePath(m_resource.getURL()); 188 189 if ((contentType == null) 190 || (contentType.equals("application/octet-stream") == true)) { 191 String decodedFileName = 192 java.net.URLDecoder.decode(fileName, HarmoniseNameResolver.UTF_8); 193 194 195 if(m_logger.isLoggable(Level.FINE)) { 196 String sMsg = 197 "DAV: Getting extension from [" 198 + decodedFileName 199 + "]"; 200 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", sMsg); 201 } 202 203 204 int dotIndex = decodedFileName.lastIndexOf("."); 205 if (dotIndex > 0) { 206 String ext = decodedFileName.substring(dotIndex + 1); 207 208 contentType = MimeTypeMapping.getMimeTypeFromExtension(ext); 209 } 210 } 211 212 User usr = 213 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 214 .getUser(m_resource); 215 216 if (m_child != null) { 218 if (m_child.isLiveVersion() == true) { 220 Profile prof = m_child.getProfile(); 221 Property startProp = 222 PropertyFactory.getPropertyFromName( 223 m_dsi, 224 HarmoniseNameResolver.START_PROP_NAME); 225 prof.removeProperty(startProp); 226 } 227 228 if (m_child instanceof Asset) { 229 if(m_logger.isLoggable(Level.FINE)) { 230 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "Saving existng asset"); 231 } 232 233 Asset asset = (Asset) m_child; 234 235 if (isAssetSavedAsText(contentType) == true) { 236 237 asset.setURI(getOutputStreamAsString()); 238 } else { 239 File file = new File(fileName); 240 asset.setContentFile(file); 241 242 if(m_logger.isLoggable(Level.FINE)) { 243 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "Guessed content type - " 244 + asset.getContentType()); 245 } 246 247 } 248 249 if (contentType != null) { 250 asset.setContentType(contentType); 251 } 252 } else if (m_child instanceof TextResource) { 253 if(m_logger.isLoggable(Level.FINE)) { 254 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "saving existing document"); 255 } 256 257 TextResource txt = (TextResource) m_child; 258 259 txt.setContent(getOutputStreamAsString()); 260 if (contentType != null) { 261 262 if (m_child instanceof XMLResource 263 && contentType.equals("application/octet-stream")) { 264 txt.setContentType( 265 MimeTypeMapping.XML.getMimeType()); 266 } else { 267 txt.setContentType(contentType); 268 } 269 270 } 271 272 } else if (m_child instanceof WebPage) { 273 WebPageResourceAdapter page = 274 new WebPageResourceAdapter((WebPage) m_child); 275 page.populate(getOutputStreamAsString()); 276 } 277 278 m_child = 279 (AbstractChildObject) CommandWrapper.save( 280 m_dsi, 281 m_child, 282 usr); 283 284 } else { 285 287 String sResourcePath = 288 URLDecoder.decode( 289 m_resource.getURL().getPath(), 290 HarmoniseNameResolver.UTF_8); 291 292 String sResourceName = 293 HarmoniseNameResolver.getLastSegment(sResourcePath); 294 295 String parentPath = 296 HarmoniseNameResolver.getPathParent(sResourcePath); 297 298 AbstractParentObject parentObj = 299 (AbstractParentObject) HarmoniseNameResolver.getObjectFromURL( 300 m_dsi, 301 parentPath); 302 303 if(parentObj.isLiveVersion() == false) { 305 throw new WebDAVException(WebDAVStatus.SC_FORBIDDEN,"Collection must be live to add a child"); 306 } 307 308 if(m_logger.isLoggable(Level.FINE)) { 309 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "child's parent's name:" + parentPath); 310 } 311 312 m_child = 313 (AbstractChildObject) Class 314 .forName( 315 HarmoniseNameResolver.getChildTypeFromURL(sResourcePath)) 316 .newInstance(); 317 m_child.setDataStoreInterface(m_dsi); 318 319 m_child.setName(sResourceName); 320 321 Profile prof = new Profile(this.m_dsi, m_child); 322 prof.setName(sResourceName); 323 m_child.setProfile(prof); 324 325 if (m_child instanceof Asset) { 327 Asset asset = (Asset) m_child; 328 329 if (isAssetSavedAsText(contentType) == true) { 330 331 asset.setURI(getOutputStreamAsString()); 332 } else { 333 File file = new File(fileName); 334 asset.setContentFile(file); 335 } 336 337 if (contentType != null) { 338 asset.setContentType(contentType); 339 } 340 } else if (m_child instanceof TextResource) { 341 TextResource doc = (TextResource) m_child; 342 343 doc.setContent(getOutputStreamAsString()); 344 345 if (m_child instanceof XMLResource 346 && (contentType == null 347 || contentType.equals("application/octet-stream"))) { 348 doc.setContentType(MimeTypeMapping.XML.getMimeType()); 349 } else { 350 doc.setContentType(contentType); 351 } 352 } else if (m_child instanceof Property) { 353 try { 355 ((Property) m_child).setRange(new StringRange()); 356 } catch(InvalidRangeException e) { 357 } 359 360 } else if (m_child instanceof WebPage) { 361 WebPageResourceAdapter page = 362 new WebPageResourceAdapter((WebPage) m_child); 363 page.populate(getOutputStreamAsString()); 364 } 365 366 m_child = 367 (AbstractChildObject) CommandWrapper.save( 368 m_dsi, 369 m_child, 370 usr); 371 372 parentObj.acquireEditWriteLock(); 373 try { 374 parentObj.addChild(m_child); 375 376 parentObj.save(); 378 } finally { 379 parentObj.releaseEditWriteLock(); 380 } 381 382 if (m_child instanceof User) { 385 AuthorityProfile secProf = new AuthorityProfile(m_dsi); 387 m_child.addProfile(secProf); 388 389 Property roleProp = 390 PropertyFactory.getPropertyFromName( 391 m_dsi, 392 AuthorizationValidator.PROP_ROLE); 393 ChildObjectPropertyInstance roleInst = 394 new ChildObjectPropertyInstance(m_dsi, roleProp); 395 396 List vals = 397 ((AbsoluteChildObjectRange) roleProp.getRange()) 398 .getAvailableValues(); 399 400 boolean bFound = false; 401 402 Iterator iter = vals.iterator(); 403 404 while (iter.hasNext() && bFound == false) { 405 Value tmpVal = (Value) iter.next(); 406 407 if (tmpVal.getName().equals("BROWSER")) { 408 roleInst.addValue(tmpVal); 409 secProf.addPropertyInstance(roleInst); 410 bFound = true; 411 } 412 } 413 414 } 415 416 if(m_logger.isLoggable(Level.FINE)) { 417 m_logger.logp(Level.FINE, this.getClass().getName(), "closeContentsOutputStream", "Adding new document or asset:" + sResourceName); 418 } 419 420 } 421 422 if (m_auxillary != null) { 423 m_auxillary.save(usr, m_child); 424 } 425 } catch(WebDAVException e) { 426 throw e; 428 } catch (ClassCastException e) { 429 m_logger.log(Level.WARNING, "closeContentsOutputStream", e); 430 throw new WebDAVException( 431 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 432 e.getLocalizedMessage()); 433 } catch (APMException e) { 434 throw new WebDAVException( 435 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 436 e.getLocalizedMessage()); 437 } catch (NameResolverException e) { 438 throw new WebDAVException( 439 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 440 e.getLocalizedMessage()); 441 } catch (InstantiationException e) { 442 throw new WebDAVException( 443 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 444 e.getLocalizedMessage()); 445 } catch (IllegalAccessException e) { 446 throw new WebDAVException( 447 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 448 e.getLocalizedMessage()); 449 } catch (ClassNotFoundException e) { 450 throw new WebDAVException( 451 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 452 e.getLocalizedMessage()); 453 } catch (IOException e) { 454 m_logger.log(Level.WARNING, "closeContentsOutputStream", e); 455 throw new WebDAVException( 456 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 457 e.getLocalizedMessage()); 458 } catch (InvalidChildException e) { 459 m_logger.log(Level.WARNING, "closeContentsOutputStream", e); 460 461 throw new WebDAVException( 462 WebDAVStatus.SC_FORBIDDEN, 463 e.getLocalizedMessage()); 464 }catch (InvalidNameException e) { 465 throw new WebDAVException( 466 WebDAVStatus.SC_FORBIDDEN, 467 e.getLocalizedMessage()); 468 } catch (InvalidXMLContentException e) { 469 m_logger.log(Level.WARNING, "closeContentsOutputStream", e); 470 throw new WebDAVException( 471 WebDAVStatus.SC_BAD_REQUEST, 472 e.getLocalizedMessage()); 473 } catch (HarmoniseException e) { 474 m_logger.log(Level.WARNING, "closeContentsOutputStream", e); 475 throw new WebDAVException( 476 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 477 e.getLocalizedMessage()); 478 } 479 480 m_openedOutputStream = null; 481 } 482 483 486 public void createBinding(String bindName, URL sourceURL) 487 throws WebDAVException { 488 try { 489 490 if ((m_child instanceof AbstractParentObject) == false) { 491 throw new WebDAVException( 492 WebDAVStatus.SC_BAD_REQUEST, 493 "Resource not collection"); 494 } 495 496 AbstractParentObject parentObj = (AbstractParentObject) m_child; 497 498 AbstractChildObject child = 499 HarmoniseNameResolver.getObjectFromURL(m_dsi, sourceURL); 500 501 if (child.getName().equals(bindName) == false) { 502 throw new WebDAVException( 503 WebDAVStatus.SC_FORBIDDEN, 504 "Server doesn't support changing the name of the resource for the binding"); 505 } 506 507 parentObj.acquireEditWriteLock(); 508 try { 509 parentObj.addChild(child, true); 510 511 if (parentObj == null) { 512 throw new WebDAVException( 513 WebDAVStatus.SC_BAD_REQUEST, 514 "Parent not found"); 515 } 516 517 CommandWrapper.save( 518 m_dsi, 519 parentObj, 520 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 521 .getUser(m_resource)); 522 } finally { 523 parentObj.releaseEditWriteLock(); 524 } 525 526 527 } catch (NameResolverException e) { 528 throw new WebDAVException( 529 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 530 e.getLocalizedMessage()); 531 } catch (InvalidChildException e) { 532 throw new WebDAVException( 533 WebDAVStatus.SC_BAD_REQUEST, 534 e.getLocalizedMessage()); 535 } catch (PopulateException e) { 536 throw new WebDAVException( 537 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 538 e.getLocalizedMessage()); 539 } catch (DataAccessException e) { 540 throw new WebDAVException( 541 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 542 e.getLocalizedMessage()); 543 } catch (EditException e) { 544 throw new WebDAVException( 545 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 546 e.getLocalizedMessage()); 547 } 548 } 549 550 553 public void createCollection(String localName) throws WebDAVException { 554 555 try { 556 String newURL = localName.replace(File.separatorChar, '/'); 557 558 newURL = new URL(m_resource.getURL(), newURL).getPath(); 559 560 if(m_logger.isLoggable(Level.FINE)) { 561 m_logger.logp(Level.FINE, this.getClass().getName(), "createCollection", "========== local name - " + localName); 562 m_logger.logp(Level.FINE, this.getClass().getName(), "createCollection", "Creating collection:" + newURL); 563 } 564 565 String parentURL = HarmoniseNameResolver.getPathParent(newURL); 566 567 if(m_logger.isLoggable(Level.FINE)) { 568 m_logger.logp(Level.FINE, this.getClass().getName(), "createCollection", "New collection parent:" + parentURL); 569 } 570 571 AbstractParentObject parent = 572 (AbstractParentObject) HarmoniseNameResolver.getObjectFromURL( 573 m_dsi, 574 parentURL); 575 576 if (parent != null) { 577 List childClassnames = parent.getChildClassNames(); 578 Class clss = parent.getClass(); 579 580 Iterator iter = childClassnames.iterator(); 581 boolean bFound = false; 582 583 while (iter.hasNext() && bFound == false) { 584 String sClassname = (String ) iter.next(); 585 Class tmpClass = Class.forName(sClassname); 586 if(AbstractParentObject.class.isAssignableFrom(tmpClass)) { 587 clss = tmpClass; 588 bFound = true; 589 } 590 } 591 592 AbstractParentObject newObj = 593 (AbstractParentObject) clss.newInstance(); 594 newObj.setDataStoreInterface(m_dsi); 595 596 String newName = HarmoniseNameResolver.getLastSegment(newURL); 597 598 newObj.setName(newName); 599 600 Profile parentPro = parent.getProfile(); 601 602 Profile pro = null; 603 604 if (parentPro != null) { 605 pro = (Profile) parentPro.clone(); 606 } 607 608 if (pro == null) { 609 pro = new Profile(this.m_dsi); 610 } 611 612 pro.setName(newName); 613 newObj.setProfile(pro); 614 615 User usr = 616 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 617 .getUser(m_resource); 618 619 newObj = 620 (AbstractParentObject) CommandWrapper.save( 621 m_dsi, 622 newObj, 623 usr); 624 625 parent.acquireEditWriteLock(); 626 try { 627 parent.addChild(newObj); 628 629 CommandWrapper.save(m_dsi, parent, usr); 631 } finally { 632 parent.releaseEditWriteLock(); 633 } 634 635 636 if (ConfigSettings 637 .getBoolProperty( 638 HarmoniseNameResolver.PNAME_AUTO_APPROVE_COLLECTIONS, 639 "true") 640 == true) { 641 642 CommandWrapper.changeStatus( 644 m_dsi, 645 newObj, 646 usr, 647 Status.APPROVED); 648 649 if (m_auxillary != null) { 650 m_auxillary.changeStatus( 651 usr, 652 newObj, 653 Status.UNAPPROVED, 654 Status.APPROVED); 655 } 656 } 657 } else { 658 m_logger.logp(Level.WARNING, this.getClass().getName(), "createCollection", "Parent section not found:" + parentURL); 659 throw new WebDAVException( 660 WebDAVStatus.SC_BAD_REQUEST, 661 "problem creating new section"); 662 } 663 664 } catch (Exception e) { 665 throw ExceptionTransformer.transform(e); 666 } 667 668 } 669 670 673 public void createLockNullResource() throws WebDAVException { 674 org.w3c.dom.Document document = m_resource.loadProperties(); 675 m_resource.saveProperties(document); 676 } 677 678 681 public void move(String destLocation) throws WebDAVException { 682 try { 683 destLocation = destLocation.replace(File.separatorChar, '/'); 684 destLocation = new URL(m_resource.getURL(), destLocation).getPath(); 685 686 String oldParentURL = 687 HarmoniseNameResolver.getPathParent( 688 URLDecoder.decode( 689 m_resource.getURL().getPath(), 690 HarmoniseNameResolver.UTF_8)); 691 692 AbstractParentObject oldParentObj = 693 (AbstractParentObject) HarmoniseNameResolver.getObjectFromURL( 694 this.m_dsi, 695 oldParentURL); 696 697 AbstractParentObject newParent = 698 (AbstractParentObject) HarmoniseNameResolver.getObjectFromURL( 699 this.m_dsi, 700 HarmoniseNameResolver.getPathParent(destLocation)); 701 702 if (newParent == null) { 703 throw new WebDAVException( 704 WebDAVStatus.SC_NOT_FOUND, 705 "Destination not found"); 706 } 707 708 if(m_logger.isLoggable(Level.FINE)) { 710 m_logger.logp(Level.FINE, this.getClass().getName(), "move", "Saving " + m_child.getClass().getName()); 711 } 712 713 String sCurrentName = m_child.getName(); 714 String sNewName = HarmoniseNameResolver.getLastSegment(destLocation); 715 716 if (sCurrentName.equals(sNewName) == false) { 717 if (m_child.getStatus() != Status.APPROVED 718 || m_child.getPendingVersions().size() > 0) { 719 throw new WebDAVException( 720 WebDAVStatus.SC_FORBIDDEN, 721 "Resource must be published before name change and can't have any pending versions"); 722 } else { 723 m_child.setName(sNewName); 724 } 725 } 726 727 User usr = 728 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 729 .getUser(m_resource); 730 731 if (oldParentObj.equals(newParent) == false) { 732 boolean bIsDefault = false; 733 734 if (oldParentObj.equals(m_child.getRealParent())) { 735 bIsDefault = true; 736 } 737 738 oldParentObj.removeChild(m_child); 739 740 CommandWrapper.save(m_dsi, oldParentObj, usr); 741 742 newParent.acquireEditWriteLock(); 743 try { 744 if (bIsDefault == true) { 745 if(m_logger.isLoggable(Level.FINE)) { 746 m_logger.logp(Level.FINE, this.getClass().getName(), "move", "Setting as default group " + newParent.getName()); 747 } 748 749 newParent.addChild(m_child); 750 } else { 751 newParent.addChild(m_child, true); 752 } 753 754 CommandWrapper.save(m_dsi, newParent, usr); 755 } finally { 756 newParent.releaseEditWriteLock(); 757 } 758 759 if(m_logger.isLoggable(Level.FINE)) { 760 m_logger.logp(Level.FINE, this.getClass().getName(), "move", "new mapping - " 761 + destLocation 762 + ":" 763 + m_child.getId()); 764 } 765 766 } 767 768 if (m_child.isChanged() == true) { 770 m_child = CommandWrapper.save(m_dsi, m_child, usr); 771 m_child = 772 CommandWrapper.changeStatus( 773 m_dsi, 774 m_child, 775 usr, 776 Status.APPROVED); 777 } 778 779 } catch (DataAccessException e) { 780 throw new WebDAVException( 781 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 782 e.getLocalizedMessage()); 783 } catch (UnsupportedEncodingException e) { 784 throw new WebDAVException( 785 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 786 e.getLocalizedMessage()); 787 } catch (MalformedURLException e) { 788 throw new WebDAVException( 789 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 790 e.getLocalizedMessage()); 791 } catch (NameResolverException e) { 792 throw new WebDAVException( 793 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 794 e.getLocalizedMessage()); 795 } catch (PopulateException e) { 796 throw new WebDAVException( 797 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 798 e.getLocalizedMessage()); 799 } catch (InvalidChildException e) { 800 m_logger.log(Level.INFO, "move", e); 801 802 throw new WebDAVException( 803 WebDAVStatus.SC_FORBIDDEN, 804 e.getLocalizedMessage()); 805 } catch (InvalidNameException e) { 806 throw new WebDAVException( 807 WebDAVStatus.SC_FORBIDDEN, 808 e.getLocalizedMessage()); 809 } catch (EditException e) { 810 throw new WebDAVException( 811 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 812 e.getLocalizedMessage()); 813 } 814 } 815 816 819 public void delete() throws WebDAVException { 820 try { 821 if(m_logger.isLoggable(Level.FINE)) { 822 m_logger.logp(Level.FINE, this.getClass().getName(), "delete", "Deleting " + m_child.getName()); 823 } 824 825 if (m_child instanceof AbstractParentObject) { 827 828 if (((AbstractParentObject) m_child).getChildren().size() 829 > 0) { 830 throw new WebDAVException( 831 WebDAVStatus.SC_FORBIDDEN, 832 "Can't delete collection with members"); 833 } 834 835 } 836 837 String sResourcePath = m_resource.getURL().getPath(); 838 839 boolean bArchive = true; 840 AbstractParentObject parentObj = null; 841 842 if (HarmoniseNameResolver.isVersionPath(sResourcePath) == false) { 843 AbstractParentObject defaultParentObj = m_child.getRealParent(); 844 845 String parentPath = 846 HarmoniseNameResolver.getPathParent( 847 URLDecoder.decode( 848 sResourcePath, 849 HarmoniseNameResolver.UTF_8)); 850 851 if(m_logger.isLoggable(Level.FINE)) { 852 m_logger.logp(Level.FINE, this.getClass().getName(), "delete", "Going to look for " + parentPath); 853 } 854 855 parentObj = 856 (AbstractParentObject) HarmoniseNameResolver.getObjectFromURL( 857 this.m_dsi, 858 parentPath); 859 860 if(m_logger.isLoggable(Level.FINE)) { 861 m_logger.logp(Level.FINE, this.getClass().getName(), "delete", "default parent - " + defaultParentObj.getName()); 862 863 m_logger.logp(Level.FINE, this.getClass().getName(), "delete"," current parent - " + parentObj.getName()); 864 } 865 866 bArchive = 867 parentObj.getFullPath().equals( 868 defaultParentObj.getFullPath()); 869 } 870 871 if (bArchive == true) { 872 if(m_logger.isLoggable(Level.FINE)) { 873 m_logger.logp(Level.FINE, this.getClass().getName(), "delete","Deleting " + m_child.getName()); 874 } 875 876 User usr = 877 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 878 .getUser(m_resource); 879 880 if (m_auxillary != null) { 882 m_auxillary.delete(usr, m_child); 883 } 884 885 CommandWrapper.archive(m_dsi, m_child, usr); 886 887 } else { 888 if(m_logger.isLoggable(Level.FINE)) { 889 m_logger.logp(Level.FINE, this.getClass().getName(), "delete","Removing child " + m_child.getName()); 890 } 891 892 parentObj.removeChild(m_child); 893 parentObj.save(); 894 } 895 896 if(m_logger.isLoggable(Level.FINE)) { 897 m_logger.logp(Level.FINE, this.getClass().getName(), "delete","Deleted"); 898 } 899 } catch (Exception e) { 900 m_logger.log(Level.WARNING, "delete", e); 901 902 throw new WebDAVException( 903 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 904 e.getMessage()); 905 } 906 } 907 908 911 public boolean exists() throws WebDAVException { 912 boolean bExists = false; 913 914 if (m_child != null) { 915 if(m_logger.isLoggable(Level.FINE)) { 916 m_logger.logp(Level.FINE, this.getClass().getName(), "exists","Checking " + m_child.getClass() + " " + m_child.getId()); 917 } 918 919 bExists = m_child.exists(); 920 } else { 921 URL url = m_resource.getURL(); 922 bExists = HarmoniseNameResolver.isVirtualCollection(url) 923 || HarmoniseNameResolver.isArchivedVirtualCollection(url) 924 || HarmoniseNameResolver.isVirtualResource(url); 925 } 926 927 if(m_logger.isLoggable(Level.FINE)) { 928 m_logger.logp(Level.FINE, this.getClass().getName(), "exists",m_resource.getURL().getPath() + " exists:" + bExists); 929 } 930 931 return bExists; 932 } 933 934 937 public InputStream getContentsInputStream() throws WebDAVException { 938 InputStream is = null; 939 940 if (m_child == null) { 941 throw new WebDAVException( 942 WebDAVStatus.SC_NOT_FOUND, 943 "Resource does not exist"); 944 } 945 946 long nResLength = 0; 947 948 if (m_child instanceof Asset) { 949 try { 950 if(m_logger.isLoggable(Level.FINE)) { 951 m_logger.logp(Level.FINE, this.getClass().getName(), "getContentsInputStream","Getting inputstream for Asset"); 952 } 953 954 Asset asset = (Asset) m_child; 955 956 if (isAssetSavedAsText(asset.getContentType()) == true) { 957 String sContent = asset.getURI(); 958 is = 959 new BufferedInputStream( 960 new ByteArrayInputStream(sContent.getBytes(HarmoniseNameResolver.UTF_8))); 961 962 nResLength = sContent.getBytes().length; 963 } else { 964 File file = asset.getContentFile(); 965 966 if(m_logger.isLoggable(Level.FINE)) { 967 m_logger.logp(Level.FINE, this.getClass().getName(), "getContentsInputStream","Asset file name - " + file.getAbsolutePath()); 968 } 969 970 is = 971 new BufferedInputStream( 972 new FileInputStream(file), 973 bufferSize); 974 975 nResLength = file.length(); 976 } 977 978 m_resource.getResponseContext().contentType( 979 asset.getContentType()); 980 981 String cdstring = 982 new SimpleRFC1123DateFormat().format(new Date()); 983 m_resource.getResponseContext().lastModified(cdstring); 984 m_resource.getResponseContext().contentLength(nResLength); 985 } catch (Exception e) { 986 m_logger.log(Level.WARNING, "getContentsInputStream", e); 987 988 throw new WebDAVException( 989 WebDAVStatus.SC_SERVICE_UNAVAILABLE, 990 "Had problem creating asset input stream"); 991 } 992 } else if (m_child instanceof TextResource) { 993 try { 994 if(m_logger.isLoggable(Level.FINE)) { 995 m_logger.logp(Level.FINE, this.getClass().getName(), "getContentsInputStream","Getting inputstream for Document"); 996 } 997 998 TextResource textResource = (TextResource) m_child; 999 User usr = 1000 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 1001 .getUser(m_resource); 1002 1003 String sContent = null; 1004 if(m_auxillary != null) { 1005 1010 sContent = m_auxillary.getContent( 1011 usr, 1012 textResource, 1013 textResource.getStatus()); 1014 } else { 1015 sContent = textResource.getContent(); 1016 } 1017 1018 if(sContent != null) { 1019 is = 1020 new BufferedInputStream( 1021 new ByteArrayInputStream( 1022 sContent.getBytes(HarmoniseNameResolver.UTF_8), 1023 0, 1024 sContent.getBytes(HarmoniseNameResolver.UTF_8).length), 1025 bufferSize); 1026 } else { 1027 is = new ByteArrayInputStream("".getBytes()); 1029 } 1030 1031 1032 String sContentType = textResource.getContentType(); 1035 1036 if (sContentType == null 1037 && textResource instanceof XMLResource) { 1038 sContentType = MimeTypeMapping.XML.getMimeType(); 1039 } 1040 1041 m_resource.getResponseContext().contentType(sContentType); 1042 1043 String cdstring = 1044 new SimpleRFC1123DateFormat().format( 1045 textResource.getVersionDate()); 1046 m_resource.getResponseContext().lastModified(cdstring); 1047 } catch (Exception e) { 1048 m_logger.log(Level.WARNING, "getContentsInputStream", e); 1049 1050 throw new WebDAVException( 1051 WebDAVStatus.SC_SERVICE_UNAVAILABLE, 1052 "Had problem creating document input stream"); 1053 } 1054 } else if (m_child instanceof WebPage) { 1055 WebPageResourceAdapter page = new WebPageResourceAdapter((WebPage) m_child); 1056 1057 String sXML = page.asString(); 1058 1059 is = 1060 new BufferedInputStream( 1061 new ByteArrayInputStream(sXML.getBytes(), 0, sXML.length()), 1062 bufferSize); 1063 1064 m_resource.getResponseContext().contentType( 1065 MimeTypeMapping.XML.getMimeType()); 1066 1067 } else if (m_child instanceof AbstractParentObject) { 1068 AbstractParentObject parent = (AbstractParentObject) m_child; 1069 1070 if (parent != null) { 1071 m_resource.getResponseContext().contentType( 1072 MimeTypeMapping.XML.getMimeType()); 1073 is = parentToXMLStream(parent); 1074 } 1075 } 1076 1077 return is; 1078 } 1079 1080 1083 public OutputStream getContentsOutputStream() throws WebDAVException { 1084 OutputStream os = null; 1085 1086 User usr = 1087 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 1088 .getUser(m_resource); 1089 1090 try { 1091 String sPath = m_resource.getURL().getPath(); 1092 String sChildClass = null; 1093 1094 if (HarmoniseNameResolver.isVersionPath(sPath) == true) { 1095 sChildClass = HarmoniseNameResolver.getTypeFromVersionURL(sPath); 1096 } else { 1097 sChildClass = HarmoniseNameResolver.getChildTypeFromURL(sPath); 1098 } 1099 1100 Class clss = Class.forName(sChildClass); 1101 1102 if((m_child != null && CommandWrapper.isSaveAllowed(usr,m_child) == false) 1103 || (m_child == null && CommandWrapper.isSaveAllowed(usr,clss) == false)) { 1104 throw new WebDAVException(WebDAVStatus.SC_FORBIDDEN, "User is not allowed to save resource"); 1105 } 1106 1107 if(m_child == null && Property.class.isAssignableFrom(clss)) { 1110 String sName = null; 1111 try { 1112 sName = HarmoniseNameResolver.getResourceName(m_resource.getURL()); 1113 } catch (UnsupportedEncodingException e) { 1114 throw new WebDAVException(WebDAVStatus.SC_INTERNAL_SERVER_ERROR,e.getLocalizedMessage()); 1115 } 1116 1117 if(Character.isDigit(sName.charAt(0)) == true) { 1118 throw new WebDAVException(WebDAVStatus.SC_BAD_REQUEST, "Invalid property name - not allowed digit as first character"); 1119 } 1120 } 1121 1122 String contentType = 1123 m_resource.getContext().getRequestContext().contentType(); 1124 1125 if (Asset.class.isAssignableFrom(clss)) { 1126 if (isAssetSavedAsText(contentType) == true) { 1127 os = new ByteArrayOutputStream(); 1128 } else { 1129 try { 1130 String fileName = 1131 HarmoniseNameResolver.getFilePath(m_resource.getURL()); 1132 1133 if(m_logger.isLoggable(Level.FINE)) { 1134 m_logger.logp(Level.FINE, this.getClass().getName(), "getContentsOutputStream", "Returning buffered FileOutputStream for file: " 1135 + fileName); 1136 } 1137 1138 File file = new File(fileName); 1139 os = 1140 new BufferedOutputStream( 1141 new FileOutputStream(file), 1142 bufferSize); 1143 } catch (NameResolverException e) { 1144 m_logger.log(Level.WARNING, "getContentsOutputStream", e); 1145 1146 throw new WebDAVException( 1147 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1148 "problem opening outputstream"); 1149 } catch (FileNotFoundException e) { 1150 m_logger.log(Level.WARNING, "getContentsOutputStream", e); 1151 1152 throw new WebDAVException( 1153 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1154 "problem opening outputstream"); 1155 } 1156 } 1157 } else if (TextResource.class.isAssignableFrom(clss)) { 1158 if(m_logger.isLoggable(Level.FINE)) { 1159 m_logger.logp(Level.FINE, this.getClass().getName(), "getContentsOutputStream", "Returning buffered ByteArrayOutputStream"); 1160 } 1161 1162 os = new ByteArrayOutputStream(); 1163 } else { 1164 os = new ByteArrayOutputStream(); 1165 } 1166 } catch (NameResolverException e) { 1167 throw new WebDAVException( 1168 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1169 e.getLocalizedMessage()); 1170 } catch (ClassNotFoundException e) { 1171 throw new WebDAVException( 1172 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1173 e.getLocalizedMessage()); 1174 } 1175 1176 m_openedOutputStream = os; 1177 1178 return os; 1179 } 1180 1181 1184 public Vector getMembers() throws WebDAVException { 1185 Vector members = new Vector(); 1186 String parentName = 1187 m_resource.getName().replace(File.separatorChar, '/'); 1188 1189 if (HarmoniseNameResolver.isVersionPath(parentName) == true 1190 && m_child != null) { 1191 try { 1192 parentName = HarmoniseNameResolver.getDAVPath(m_child); 1193 } catch (NameResolverException e) { 1194 throw new WebDAVException( 1195 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1196 e.getLocalizedMessage()); 1197 } 1198 } 1199 1200 if ((parentName != null) && !parentName.endsWith("/")) { 1201 parentName = parentName + "/"; 1202 } 1203 1204 if (parentName == null) { 1205 parentName = ""; 1206 } 1207 1208 AbstractParentObject grpObj = null; 1209 1210 try { 1211 grpObj = (AbstractParentObject) m_child; 1212 } catch (ClassCastException e) { 1213 throw new WebDAVException( 1214 WebDAVStatus.SC_BAD_REQUEST, 1215 "resource not a collection"); 1216 } 1217 1218 URL resourceURL = m_resource.getURL(); 1219 1220 try { 1221 if (grpObj == null) { 1222 1223 if (HarmoniseNameResolver.isDAVRoot(resourceURL) == true) { 1224 1225 List rootParents = HarmoniseNameResolver.getRootCollections(); 1226 1227 Iterator iter = rootParents.iterator(); 1228 1229 while (iter.hasNext()) { 1230 members.addElement( 1231 createNewVirtualCollection( 1232 parentName, 1233 (String ) iter.next())); 1234 } 1235 members.addElement( 1236 createNewVirtualCollection( 1237 parentName, 1238 HarmoniseNameResolver.ARCHIVE_NAME)); 1239 1240 } else if ( 1241 HarmoniseNameResolver.isArchiveRoot(resourceURL) == true) { 1242 List rootParents = HarmoniseNameResolver.getRootCollections(); 1243 1244 Iterator iter = rootParents.iterator(); 1245 1246 while (iter.hasNext()) { 1247 members.addElement( 1248 createNewVirtualCollection( 1249 parentName, 1250 (String ) iter.next())); 1251 } 1252 } else if ( 1253 HarmoniseNameResolver.isVirtualCollection(resourceURL) == true) { 1254 List vmembers = null; 1255 1256 if (HarmoniseNameResolver.isArchiveURL(resourceURL) == true) { 1257 vmembers = 1258 HarmoniseNameResolver 1259 .getArchivedVirtualCollectionMemberNames( 1260 resourceURL); 1261 } else { 1262 vmembers = 1263 HarmoniseNameResolver.getVirtualCollectionMemberNames( 1264 resourceURL); 1265 } 1266 1267 Iterator iter = vmembers.iterator(); 1268 1269 while (iter.hasNext()) { 1270 members.addElement( 1271 createNewVirtualCollection( 1272 parentName, 1273 (String ) iter.next())); 1274 } 1275 } else if ( 1276 HarmoniseNameResolver.isArchivedVirtualCollection(resourceURL) 1277 == true) { 1278 List vmembers = 1279 HarmoniseNameResolver 1280 .getArchivedVirtualCollectionMemberNames( 1281 resourceURL); 1282 1283 Iterator iter = vmembers.iterator(); 1284 1285 while (iter.hasNext()) { 1286 members.addElement( 1287 createNewVirtualCollection( 1288 parentName, 1289 (String ) iter.next())); 1290 } 1291 } 1292 1293 } else { 1294 List children = null; 1295 Vector subgroups = new Vector(); 1296 1297 if (HarmoniseNameResolver.isArchiveURL(resourceURL) == true) { 1298 children = grpObj.getArchivedChildren(); 1299 1300 children.addAll( 1301 grpObj.getChildrenByType( 1302 AbstractParentObject.BRANCH_NODES)); 1303 1304 if(m_logger.isLoggable(Level.FINE)) { 1305 m_logger.logp(Level.FINE, this.getClass().getName(), "getMembers", "Got " + children.size() + " archived children"); 1306 } 1307 } else { 1308 children = grpObj.getChildren(); 1309 } 1310 1311 Iterator iter = children.iterator(); 1312 1313 while (iter.hasNext()) { 1314 AbstractChildObject child = 1315 (AbstractChildObject) iter.next(); 1316 1317 StringBuffer sbuf = new StringBuffer (); 1318 sbuf.append(child.getName()); 1319 1320 String sMemberName = sbuf.toString(); 1321 1322 String childName = parentName + sMemberName; 1324 1325 if(m_logger.isLoggable(Level.FINE)) { 1326 m_logger.logp(Level.FINE, this.getClass().getName(), "getMembers", "adding document:" 1327 + childName 1328 + "(" 1329 + child.hashCode() 1330 + ")"); 1331 } 1332 1333 ResourceImpl member = null; 1334 1335 if (child instanceof AbstractParentObject) { 1336 member = 1337 new CollectionImpl( 1338 getChildURL(sMemberName), 1339 childName, 1340 null); 1341 1342 } else { 1343 member = 1344 new ResourceImpl( 1345 getChildURL(sMemberName), 1346 childName); 1347 } 1348 1349 member.setRequestContext(m_resource.getContext()); 1350 members.addElement(member); 1351 } 1352 } 1353 } catch (DataAccessException e) { 1354 m_logger.log(Level.WARNING, "getMembers", e); 1355 1356 throw new WebDAVException( 1357 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1358 e.getLocalizedMessage()); 1359 } 1360 1361 return members; 1362 } 1363 1364 1367 private URL getChildURL(String sChildName) throws WebDAVException { 1368 URL childURL = null; 1369 1370 String parentName = 1371 m_resource.getName().replace(File.separatorChar, '/'); 1372 1373 try { 1374 if (HarmoniseNameResolver.isVersionPath(parentName) == true 1375 && m_child != null) { 1376 URL resourceURL = m_resource.getURL(); 1377 StringBuffer sParentURL = new StringBuffer (); 1378 sParentURL.append(resourceURL.getProtocol()); 1379 sParentURL.append("://"); 1380 sParentURL.append(resourceURL.getHost()); 1381 sParentURL.append(":"); 1382 sParentURL.append(resourceURL.getPort()); 1383 sParentURL.append("/"); 1384 sParentURL.append(HarmoniseNameResolver.getDAVPath(m_child)); 1385 if (sParentURL.toString().endsWith("/") == false) { 1386 sParentURL.append("/"); 1387 } 1388 1389 childURL = new URL(sParentURL.append(sChildName).toString()); 1390 1391 } else { 1392 childURL = 1393 ((CollectionImpl) m_resource).getChildURL( 1394 URLEncoder.encode(sChildName, HarmoniseNameResolver.UTF_8)); 1395 } 1396 } catch (MalformedURLException e) { 1397 throw new WebDAVException( 1398 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1399 e.getLocalizedMessage()); 1400 } catch (NameResolverException e) { 1401 throw new WebDAVException( 1402 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1403 e.getLocalizedMessage()); 1404 } catch (UnsupportedEncodingException e) { 1405 throw new WebDAVException( 1406 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1407 e.getLocalizedMessage()); 1408 } 1409 1410 return childURL; 1411 1412 } 1413 1414 1423 private CollectionImpl createNewVirtualCollection( 1424 String parentName, 1425 String sColName) 1426 throws WebDAVException { 1427 CollectionImpl collection = null; 1428 1429 collection = 1430 new CollectionImpl( 1431 ((CollectionImpl) m_resource).getChildURL(sColName), 1432 parentName + sColName, 1433 null); 1434 1435 collection.setRequestContext(m_resource.getContext()); 1436 1437 return collection; 1438 } 1439 1440 1443 public void initialize(ResourceImpl resource) { 1444 this.m_resource = resource; 1445 1446 try { 1447 this.m_dsi = DataStoreInterfaceFactory.getDataStoreInterface(); 1448 1449 URL resourceURL = m_resource.getURL(); 1450 1451 if (HarmoniseNameResolver.isDAVRoot(resourceURL) == false 1452 && HarmoniseNameResolver.isVirtualCollection(resourceURL) == false) { 1453 m_child = HarmoniseNameResolver.getObjectFromURL(m_dsi, resourceURL); 1454 } 1455 1456 if (m_auxillary == null) { 1457 m_auxillary = APMFactory.getAPM(); 1458 } 1459 } catch (Exception e) { 1460 m_logger.log(Level.WARNING, "initialize", e); 1461 } 1462 } 1463 1464 1467 public boolean isCollection() throws WebDAVException { 1468 boolean bRtn = false; 1469 1470 if (m_child != null) { 1471 bRtn = m_child instanceof AbstractParentObject; 1472 } else { 1473 URL resourceURL = m_resource.getURL(); 1474 bRtn = HarmoniseNameResolver.isVirtualCollection(resourceURL) || HarmoniseNameResolver.isArchivedVirtualCollection(resourceURL); 1475 } 1476 1477 if(m_logger.isLoggable(Level.FINE)) { 1478 m_logger.logp(Level.FINE, this.getClass().getName(), "isCollection","Is collection - " + bRtn); 1479 } 1480 1481 return bRtn; 1482 } 1483 1484 1487 public boolean isLockNull() throws WebDAVException { 1488 return false; 1489 } 1490 1491 1494 public byte[] performWith(String args) throws WebDAVException { 1495 StringWriter buf = new StringWriter(); 1496 1497 try { 1498 Runtime runtime = Runtime.getRuntime(); 1499 Process p = runtime.exec(m_resource.getName() + " " + args); 1500 BufferedReader inputStream = 1501 new BufferedReader(new InputStreamReader(p.getInputStream())); 1502 int ch = -1; 1503 1504 while ((ch = inputStream.read()) != -1) { 1505 buf.write(ch); 1506 } 1507 } catch (Exception e) { 1508 m_logger.log(Level.WARNING, e.getLocalizedMessage(), e); 1509 } 1510 1511 return buf.toString().getBytes(); 1512 } 1513 1514 1519 private InputStream parentToXMLStream(AbstractParentObject parent) 1520 throws WebDAVException { 1521 org.w3c.dom.Document document = null; 1522 1523 try { 1524 document = 1525 DocumentBuilderFactory 1526 .newInstance() 1527 .newDocumentBuilder() 1528 .newDocument(); 1529 } catch (Exception e) { 1530 throw new WebDAVException( 1531 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1532 e.getMessage()); 1533 } 1534 1535 Element collection = document.createElement("D:collection"); 1536 collection.setAttribute("xmlns:D", "DAV:"); 1537 document.appendChild(collection); 1538 1539 try { 1540 List children = parent.getChildren(); 1541 1542 Iterator iter = children.iterator(); 1543 1544 while (iter.hasNext()) { 1545 AbstractChildObject child = (AbstractChildObject) iter.next(); 1546 String docName = child.getName(); 1547 1548 Element uri = document.createElement("D:member"); 1550 uri.appendChild(document.createTextNode(docName)); 1551 collection.appendChild(uri); 1552 } 1553 } catch (DataAccessException e) { 1554 throw new WebDAVException( 1555 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1556 e.getLocalizedMessage()); 1557 } 1558 1559 ByteArrayOutputStream os = new ByteArrayOutputStream(); 1560 1561 try { 1562 PrintWriter pout = 1563 new PrintWriter( 1564 new OutputStreamWriter(os, Resource.defaultCharEncoding), 1565 false); 1566 pout.print(XMLUtility.printNode(document.getDocumentElement())); 1567 } catch (UnsupportedEncodingException e) { 1568 m_logger.log(Level.WARNING, e.getLocalizedMessage(), e); 1569 throw new WebDAVException(WebDAVStatus.SC_INTERNAL_SERVER_ERROR,e.getMessage()); 1570 } 1571 1572 m_resource.getResponseContext().contentType("text/xml"); 1573 1574 return new ByteArrayInputStream(os.toByteArray()); 1575 } 1576 1577 1578 1581 public boolean isVersionable() throws WebDAVException { 1582 return false; 1583 } 1584 1585 1586 1589 public List getAllowedMethods() throws WebDAVException { 1590 List allowedMethods = null; 1591 1592 if (HarmoniseNameResolver.isVirtualCollection(m_resource.getURL()) == true) { 1593 allowedMethods = new ArrayList(VIRTUAL_DIR_ALLOWED_METHODS); 1594 } 1595 if (HarmoniseNameResolver.isArchivedVirtualCollection(m_resource.getURL()) 1596 == true) { 1597 allowedMethods = new ArrayList(VIRTUAL_DIR_ALLOWED_METHODS); 1598 } else if ( 1599 HarmoniseNameResolver.isArchiveURL(m_resource.getURL()) == true 1600 || (m_child != null && m_child.isHistorical())) { 1601 allowedMethods = new ArrayList(ARCHIVE_ALLOWED_METHODS); 1602 try { 1603 AbstractChildObject liveChild = 1604 (AbstractChildObject) m_child.getLiveVersion(); 1605 if ((m_child instanceof AbstractParentObject) == false) { 1606 if (liveChild == null 1607 || liveChild.getPendingVersions().size() == 0) { 1608 allowedMethods.add(CheckOutMethod.METHOD_NAME); 1609 } 1610 } 1611 } catch (DataAccessException e) { 1612 throw new WebDAVException( 1613 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1614 e.getLocalizedMessage()); 1615 } 1616 } else { 1617 1618 allowedMethods = new Vector(STD_ALLOWED_METHODS); 1619 1620 if (m_child instanceof AbstractParentObject) { 1621 allowedMethods.add(OrderPatchMethod.METHOD_NAME); 1622 allowedMethods.add(MkcolMethod.METHOD_NAME); 1623 } 1624 1625 allowedMethods = filterAllowedMethods(allowedMethods); 1626 } 1627 1628 return allowedMethods; 1629 } 1630 1631 1638 protected List filterAllowedMethods(List allowedMethods) 1639 throws WebDAVException { 1640 List filteredList = new Vector(); 1641 1642 User usr = 1643 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()).getUser(m_resource); 1644 1645 Iterator iter = allowedMethods.iterator(); 1646 1647 while (iter.hasNext()) { 1648 String sMethod = (String ) iter.next(); 1649 1650 if (VIRTUAL_DIR_ALLOWED_METHODS.contains(sMethod)) { 1651 filteredList.add(sMethod); 1652 } else { 1653 String sCmd = (String ) DAV_HARMONISE_COMMAND_MAPPING.get(sMethod); 1654 1655 if (sCmd != null) { 1656 try { 1657 if (AuthorizationValidator 1658 .isCommandAvailable(usr, m_child, sCmd) 1659 == true) { 1660 filteredList.add(sMethod); 1661 } 1662 } catch (AuthorizationException e) { 1663 m_logger.log(Level.WARNING, "filterAllowedMethods", e); 1665 } 1666 } 1667 1668 } 1669 1670 } 1671 1672 return filteredList; 1673 } 1674 1675 1678 public void setOrdering(org.w3c.dom.Document orderPatch) 1679 throws WebDAVException { 1680 1681 if (m_child == null) { 1682 throw new WebDAVException( 1683 WebDAVStatus.SC_NOT_FOUND, 1684 "Resource not a collection"); 1685 } 1686 1687 if ((m_child instanceof AbstractParentObject) == false) { 1688 throw new WebDAVException( 1689 WebDAVStatus.SC_BAD_REQUEST, 1690 "Resource not a collection"); 1691 } 1692 1693 try { 1694 AbstractParentObject parent = (AbstractParentObject) m_child; 1695 1696 Element orderEl = orderPatch.getDocumentElement(); 1697 1698 NodeList nodes = 1699 orderEl.getElementsByTagNameNS( 1700 NamespaceType.DAV.getURI(), 1701 TAG_ORDER_MEMBER); 1702 1703 LinkedList children = new LinkedList(parent.getChildren()); 1704 1705 for (int i = 0; i < nodes.getLength(); i++) { 1706 Element tmpEl = (Element) nodes.item(i); 1707 1708 Element segmentEl = 1709 (Element) tmpEl 1710 .getElementsByTagNameNS( 1711 NamespaceType.DAV.getURI(), 1712 TAG_SEGMENT) 1713 .item(0); 1714 Element positionEl = 1715 (Element) tmpEl 1716 .getElementsByTagNameNS( 1717 NamespaceType.DAV.getURI(), 1718 TAG_POSITION) 1719 .item(0); 1720 1721 String sChildName = 1722 segmentEl.getChildNodes().item(0).getNodeValue(); 1723 1724 sChildName = HarmoniseNameResolver.stripExtension(sChildName); 1725 1726 AbstractChildObject child = parent.getChildByName(sChildName); 1727 1728 if (child == null) { 1729 throw new WebDAVException( 1730 WebDAVStatus.SC_FORBIDDEN, 1731 sChildName + " is not a collection member"); 1732 } 1733 1734 Element specEl = XMLUtils.getFirstElementChild(positionEl); 1735 1736 String sSpecifier = specEl.getLocalName(); 1737 1738 children.remove(child); 1740 if (sSpecifier.equals(TAG_FIRST)) { 1741 children.addFirst(child); 1742 } else if (sSpecifier.equals(TAG_LAST)) { 1743 children.addLast(child); 1744 } else if (sSpecifier.equals(TAG_BEFORE)) { 1745 String sBeforeChildName = 1746 specEl 1747 .getElementsByTagNameNS( 1748 NamespaceType.DAV.getURI(), 1749 TAG_SEGMENT) 1750 .item(0) 1751 .getChildNodes() 1752 .item(0) 1753 .getNodeValue(); 1754 sBeforeChildName = 1755 HarmoniseNameResolver.stripExtension(sBeforeChildName); 1756 1757 AbstractChildObject sBeforeChild = 1758 parent.getChildByName(sBeforeChildName); 1759 1760 int nIndex = children.indexOf(sBeforeChild); 1761 children.add(nIndex, child); 1762 1763 } else if (sSpecifier.equals(TAG_AFTER)) { 1764 String sAfterChildName = 1765 specEl 1766 .getElementsByTagNameNS( 1767 NamespaceType.DAV.getURI(), 1768 TAG_SEGMENT) 1769 .item(0) 1770 .getChildNodes() 1771 .item(0) 1772 .getNodeValue(); 1773 sAfterChildName = 1774 HarmoniseNameResolver.stripExtension(sAfterChildName); 1775 1776 AbstractChildObject sAfterChild = 1777 parent.getChildByName(sAfterChildName); 1778 1779 int nIndex = children.indexOf(sAfterChild); 1780 children.add(nIndex + 1, child); 1781 } 1782 1783 } 1784 1785 if(m_logger.isLoggable(Level.FINE)) { 1786 m_logger.logp(Level.FINE, this.getClass().getName(), "setOrdering", "New order - " + children); 1787 } 1788 1789 parent.setChildren(children); 1791 1792 CommandWrapper.save( 1793 m_dsi, 1794 parent, 1795 ((HarmoniseSessionManager) m_resource.getUserAuthenticator()) 1796 .getUser(m_resource)); 1797 1798 } catch (DataAccessException e) { 1799 throw new WebDAVException( 1800 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1801 e.getLocalizedMessage()); 1802 } catch (InvalidChildException e) { 1803 throw new WebDAVException( 1804 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1805 e.getLocalizedMessage()); 1806 } catch (PopulateException e) { 1807 throw new WebDAVException( 1808 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1809 e.getLocalizedMessage()); 1810 } 1811 1812 } 1813 1814 1817 public boolean isVersionURL(String url) { 1818 1819 return HarmoniseNameResolver.isVersionPath(url); 1820 } 1821 1822 1825 public String getResourceURL() throws WebDAVException { 1826 String sPath = null; 1827 1828 try { 1829 sPath = HarmoniseNameResolver.getDAVPath(m_child); 1830 } catch (NameResolverException e) { 1831 throw new WebDAVException( 1832 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1833 e.getLocalizedMessage()); 1834 } 1835 1836 return sPath; 1837 } 1838 1839 1842 public String getContentType() throws WebDAVException { 1843 String sContentType = null; 1844 1845 try { 1846 if (m_child instanceof Asset) { 1847 sContentType = ((Asset) m_child).getContentType(); 1848 } else if (m_child instanceof TextResource) { 1849 sContentType = ((TextResource) m_child).getContentType(); 1850 } 1851 } catch (DataAccessException e) { 1852 throw new WebDAVException( 1853 WebDAVStatus.SC_INTERNAL_SERVER_ERROR, 1854 e.getLocalizedMessage()); 1855 } 1856 1857 return sContentType; 1858 } 1859 1860 private String getOutputStreamAsString() throws IOException { 1861 byte[] byteArray = 1862 ((ByteArrayOutputStream) m_openedOutputStream).toByteArray(); 1863 int length = byteArray.length; 1864 1865 ByteArrayInputStream byteInputStream = 1866 new ByteArrayInputStream(byteArray); 1867 BufferedReader reader = 1868 new BufferedReader(new InputStreamReader(byteInputStream, HarmoniseNameResolver.UTF_8)); 1869 1870 char[] cbuf = new char[bufferSize]; 1871 String sNewContents = ""; 1872 StringWriter writer = new StringWriter(); 1873 1874 String temp = ""; 1875 while ((temp = reader.readLine()) != null) { 1876 writer.write(temp); 1877 } 1878 1879 String sResult = writer.toString(); 1880 1881 if(m_logger.isLoggable(Level.FINE)) { 1882 m_logger.logp(Level.FINE, this.getClass().getName(), "getOutputStreamAsString", "New doc contents: " + sResult); 1883 } 1884 1885 return sResult; 1886 } 1887 1888 1895 private boolean isAssetSavedAsText(String sContentType) { 1896 boolean bIsFile = false; 1897 1898 bIsFile = 1899 (sContentType != null 1900 && MimeTypeMapping.XSLT.getMimeTypes().contains(sContentType) 1901 == false 1902 && (sContentType.startsWith("link") 1903 || sContentType.startsWith("text"))); 1904 1905 return bIsFile; 1906 } 1907 1908} | Popular Tags |