/**
* Get file extension corresponds to MIMEType. If MIMEType is empty or equals default MIMEType
* empty string will be returned. If there is no file extension for specific MIMEType the empty
* string will be returned also. In case when there are more than one extension for specific
* MIMEType the first occurred extension in the list will be returned if MIMEType ends with this
* extension otherwise just first occurred.
*
* @param mimeType MIMEType
* @return file extension
*/
public String getExtension(String mimeType) {
String extension = resolver.getExtension(mimeType);
if (extension.length() == 0) {
// use this resolver map (the same logic as in MimeTypeResolver)
mimeType = mimeType.toLowerCase();
if (mimeType.isEmpty() || mimeType.equals(resolver.getDefaultMimeType())) {
return "";
}
List<String> values = extentions.get(mimeType);
if (values == null) {
return "";
}
String resultExt = "";
for (String ext : values) {
if (mimeType.endsWith(ext)) {
return ext;
}
if (resultExt.isEmpty()) {
resultExt = ext;
}
}
extension = resultExt;
}
return extension;
}
/**
* Get MIMEType which corresponds to file content. If file content does not allow to determine
* MIMEtype, the default MIMEType will be returned.
*
* @param filename the filename
* @param is the is
* @return String MIMEType
*/
public String getMimeType(String filename, InputStream is) {
String mimeType = getMimeType(filename);
if (resolver.getDefaultMimeType().equals(mimeType)) {
mimeType = resolver.getMimeType(filename, is);
}
return mimeType;
}
@Override
public void execute(Event<UIAvatarUploader> event) throws Exception {
WebuiRequestContext ctx = event.getRequestContext();
UIApplication uiApplication = ctx.getUIApplication();
UIAvatarUploader uiAvatarUploader = event.getSource();
UIFormUploadInput uiAvatarUploadInput = uiAvatarUploader.getChild(UIFormUploadInput.class);
UIPopupWindow uiPopup = uiAvatarUploader.getParent();
InputStream uploadedStream = uiAvatarUploadInput.getUploadDataAsStream();
if (uploadedStream == null) {
uiApplication.addMessage(
new ApplicationMessage(MSG_IMG_NOT_UPLOADED, null, ApplicationMessage.ERROR));
ctx.addUIComponentToUpdateByAjax(uiAvatarUploader);
return;
}
UploadResource uploadResource = uiAvatarUploadInput.getUploadResource();
String mimeType = uploadResource.getMimeType();
String uploadId = uiAvatarUploadInput.getUploadId();
if (!uiAvatarUploader.isAcceptedMimeType(mimeType)) {
UploadService uploadService =
(UploadService) PortalContainer.getComponent(UploadService.class);
uploadService.removeUploadResource(uploadId);
uiApplication.addMessage(
new ApplicationMessage(MSG_MIMETYPE_NOT_ACCEPTED, null, ApplicationMessage.ERROR));
ctx.addUIComponentToUpdateByAjax(uiAvatarUploader);
} else {
MimeTypeResolver mimeTypeResolver = new MimeTypeResolver();
String fileName = uploadResource.getFileName();
// @since 1.1.3
String extension = mimeTypeResolver.getExtension(mimeType);
if ("".equals(extension)) {
mimeType = uiAvatarUploader.getStandardMimeType(mimeType);
}
// Resize avatar to fixed width if can't(avatarAttachment == null) keep
// origin avatar
AvatarAttachment avatarAttachment =
ImageUtils.createResizedAvatarAttachment(
uploadedStream, WIDTH, 0, null, fileName, mimeType, null);
if (avatarAttachment == null) {
avatarAttachment =
new AvatarAttachment(
null, fileName, mimeType, uploadedStream, null, System.currentTimeMillis());
}
UploadService uploadService =
(UploadService) PortalContainer.getComponent(UploadService.class);
uploadService.removeUploadResource(uploadId);
UIAvatarUploadContent uiAvatarUploadContent =
uiAvatarUploader.createUIComponent(UIAvatarUploadContent.class, null, null);
uiAvatarUploadContent.setAvatarAttachment(avatarAttachment);
uiPopup.setUIComponent(uiAvatarUploadContent);
ctx.addUIComponentToUpdateByAjax(uiPopup);
}
}
/**
* Get MIMEType which corresponds to file extension. If file extension is unknown the default
* MIMEType will be returned. If there are more than one MIMETypes for specific extension the
* first occurred in the list will be returned.
*
* @param filename the filename
* @return String MIMEType
*/
public String getMimeType(String filename) {
String mimeType = resolver.getMimeType(filename);
if (resolver.getDefaultMimeType().equals(mimeType)) {
// default resolver didn't recognize the type
// try guess from this resolver map
String ext = filename.substring(filename.lastIndexOf(".") + 1);
if (ext.isEmpty()) {
ext = filename;
}
List<String> values = mimeTypes.get(ext.toLowerCase());
mimeType = values == null ? mimeType : values.get(0);
}
return mimeType;
}
public void execute(JobExecutionContext context) throws JobExecutionException {
Session session = null;
try {
if (LOG.isInfoEnabled()) {
LOG.info("Start Execute ImportXMLJob");
}
if (stagingStorage == null) {
JobDataMap jdatamap = context.getJobDetail().getJobDataMap();
stagingStorage = jdatamap.getString("stagingStorage");
temporaryStorge = jdatamap.getString("temporaryStorge");
if (LOG.isDebugEnabled()) {
LOG.debug("Init parameters first time :");
}
}
SessionProvider sessionProvider = SessionProvider.createSystemProvider();
String containerName = WCMCoreUtils.getContainerNameFromJobContext(context);
RepositoryService repositoryService_ =
WCMCoreUtils.getService(RepositoryService.class, containerName);
ManageableRepository manageableRepository = repositoryService_.getCurrentRepository();
PublicationService publicationService =
WCMCoreUtils.getService(PublicationService.class, containerName);
PublicationPlugin publicationPlugin =
publicationService
.getPublicationPlugins()
.get(AuthoringPublicationConstant.LIFECYCLE_NAME);
XMLInputFactory factory = XMLInputFactory.newInstance();
File stagingFolder = new File(stagingStorage);
File tempfolder = new File(temporaryStorge);
File[] files = null;
File xmlFile = null;
XMLStreamReader reader = null;
InputStream xmlInputStream = null;
int eventType;
List<LinkObject> listLink = new ArrayList<LinkObject>();
LinkObject linkObj = new LinkObject();
boolean hasNewContent = false;
if (stagingFolder.exists()) {
files = stagingFolder.listFiles();
if (files != null) {
hasNewContent = true;
for (int i = 0; i < files.length; i++) {
xmlFile = files[i];
if (xmlFile.isFile()) {
MimeTypeResolver resolver = new MimeTypeResolver();
String fileName = xmlFile.getName();
String hashCode = fileName.split("-")[0];
String mimeType = resolver.getMimeType(xmlFile.getName());
if ("text/xml".equals(mimeType)) {
xmlInputStream = new FileInputStream(xmlFile);
reader = factory.createXMLStreamReader(xmlInputStream);
while (reader.hasNext()) {
eventType = reader.next();
if (eventType == XMLEvent.START_ELEMENT && "data".equals(reader.getLocalName())) {
String data = reader.getElementText();
if (!tempfolder.exists()) tempfolder.mkdirs();
long time = System.currentTimeMillis();
File file =
new File(
temporaryStorge
+ File.separator
+ "-"
+ hashCode
+ "-"
+ time
+ ".xml.tmp");
InputStream inputStream = new ByteArrayInputStream(data.getBytes());
OutputStream out = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len;
while ((len = inputStream.read(buf)) > 0) out.write(buf, 0, len);
out.close();
inputStream.close();
}
try {
if (eventType == XMLEvent.START_ELEMENT
&& "published-content".equals(reader.getLocalName())) {
linkObj.setSourcePath(reader.getAttributeValue(0)); // --Attribute
// number
// 0 =
// targetPath
}
if (eventType == XMLEvent.START_ELEMENT
&& "type".equals(reader.getLocalName())) {
linkObj.setLinkType(reader.getElementText());
}
if (eventType == XMLEvent.START_ELEMENT
&& "title".equals(reader.getLocalName())) {
linkObj.setLinkTitle(reader.getElementText());
}
if (eventType == XMLEvent.START_ELEMENT
&& "targetPath".equals(reader.getLocalName())) {
linkObj.setLinkTargetPath(reader.getElementText());
listLink.add(linkObj);
}
if (eventType == XMLEvent.START_ELEMENT
&& "unpublished-content".equals(reader.getLocalName())) {
String contentTargetPath = reader.getAttributeValue(0);
String[] strContentPath = contentTargetPath.split(":");
StringBuffer sbContPath = new StringBuffer();
boolean flag = true;
for (int index = 2; index < strContentPath.length; index++) {
if (flag) {
sbContPath.append(strContentPath[index]);
flag = false;
} else {
sbContPath.append(":").append(strContentPath[index]);
}
}
sessionProvider = SessionProvider.createSystemProvider();
manageableRepository = repositoryService_.getCurrentRepository();
String workspace = strContentPath[1];
session = sessionProvider.getSession(workspace, manageableRepository);
String contentPath = sbContPath.toString();
if (session.itemExists(contentPath)) {
Node currentContent = (Node) session.getItem(contentPath);
HashMap<String, String> variables = new HashMap<String, String>();
variables.put("nodePath", contentTargetPath);
variables.put("workspaceName", workspace);
if (currentContent.hasProperty(
StageAndVersionPublicationConstant.PUBLICATION_LIFECYCLE_NAME)
&& AuthoringPublicationConstant.LIFECYCLE_NAME.equals(
currentContent
.getProperty(
StageAndVersionPublicationConstant
.PUBLICATION_LIFECYCLE_NAME)
.getString())
&& PublicationDefaultStates.PUBLISHED.equals(
currentContent
.getProperty(StageAndVersionPublicationConstant.CURRENT_STATE)
.getString())) {
publicationPlugin.changeState(
currentContent, PublicationDefaultStates.UNPUBLISHED, variables);
if (LOG.isInfoEnabled()) {
LOG.info(
"Change the status of the node "
+ currentContent.getPath()
+ " from "
+ PublicationDefaultStates.PUBLISHED
+ " to "
+ PublicationDefaultStates.UNPUBLISHED);
}
}
} else {
if (LOG.isWarnEnabled()) {
LOG.warn("The node " + contentPath + " does not exist");
}
}
}
} catch (Exception ie) {
if (LOG.isWarnEnabled()) {
LOG.warn("Error in ImportContentsJob: " + ie.getMessage());
}
}
}
reader.close();
xmlInputStream.close();
xmlFile.delete();
}
}
}
}
}
files = tempfolder.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
xmlFile = files[i];
InputStream inputStream = new FileInputStream(xmlFile);
reader = factory.createXMLStreamReader(inputStream);
String workspace = null;
String nodePath = new String();
while (reader.hasNext()) {
eventType = reader.next();
if (eventType == XMLEvent.START_ELEMENT) {
if (reader.getLocalName().equals("property")) {
String value = reader.getAttributeValue(0);
if (MIX_TARGET_PATH.equals(value)) {
eventType = reader.next();
if (eventType == XMLEvent.START_ELEMENT) {
reader.next();
nodePath = reader.getText();
}
} else if (MIX_TARGET_WORKSPACE.equals(value)) {
eventType = reader.next();
if (eventType == XMLEvent.START_ELEMENT) {
reader.next();
workspace = reader.getText();
}
}
}
}
}
reader.close();
inputStream.close();
session = sessionProvider.getSession(workspace, manageableRepository);
if (session.itemExists(nodePath)) session.getItem(nodePath).remove();
session.save();
String path = nodePath.substring(0, nodePath.lastIndexOf(JCR_File_SEPARATOR));
if (!session.itemExists(path)) {
String[] pathTab = path.split(JCR_File_SEPARATOR);
Node node_ = session.getRootNode();
StringBuffer path_ = new StringBuffer(JCR_File_SEPARATOR);
for (int j = 1; j < pathTab.length; j++) {
path_ = path_.append(pathTab[j] + JCR_File_SEPARATOR);
if (!session.itemExists(path_.toString())) {
node_.addNode(pathTab[j], "nt:unstructured");
}
node_ = (Node) session.getItem(path_.toString());
}
}
session.importXML(path, new FileInputStream(xmlFile), 0);
session.save();
xmlFile.delete();
if (hasNewContent) {
for (LinkObject obj : listLink) {
String[] linkTarget = obj.getLinkTargetPath().split(":");
StringBuffer itemPath = new StringBuffer();
boolean flag = true;
for (int index = 2; index < linkTarget.length; index++) {
if (flag) {
itemPath.append(linkTarget[index]);
flag = false;
} else {
itemPath.append(":");
itemPath.append(linkTarget[index]);
}
}
String[] linkSource = obj.getSourcePath().split(":");
session = sessionProvider.getSession(linkTarget[1], manageableRepository);
Node parentNode = (Node) session.getItem(itemPath.toString());
StringBuffer sourcePath = new StringBuffer();
boolean flagSource = true;
for (int index = 2; index < linkSource.length; index++) {
if (flagSource) {
sourcePath.append(linkSource[index]);
flagSource = false;
} else {
sourcePath.append(":");
sourcePath.append(linkSource[index]);
}
}
if (parentNode.hasNode(obj.getLinkTitle())) {
Node existedNode = (Node) session.getItem(itemPath + "/" + obj.getLinkTitle());
existedNode.remove();
}
session = sessionProvider.getSession(linkSource[1], manageableRepository);
Node targetNode = (Node) session.getItem(sourcePath.toString());
LinkManager linkManager = WCMCoreUtils.getService(LinkManager.class, containerName);
linkManager.createLink(parentNode, obj.getLinkType(), targetNode, obj.getLinkTitle());
}
}
}
}
if (LOG.isInfoEnabled()) {
LOG.info("End Execute ImportXMLJob");
}
} catch (RepositoryException ex) {
if (LOG.isDebugEnabled()) {
LOG.debug("Repository 'repository ' not found.");
}
} catch (Exception ex) {
if (LOG.isErrorEnabled()) {
LOG.error("Error when importing Contents : " + ex.getMessage(), ex);
}
} finally {
if (session != null) session.logout();
}
}
/**
* Set default MIMEType.
*
* @param type the new default mime type
*/
public void setDefaultMimeType(String type) {
resolver.setDefaultMimeType(type);
}
/**
* Returns default MIMEType.
*
* @return String
*/
public String getDefaultMimeType() {
return resolver.getDefaultMimeType();
}